{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "梯度提升决策树（Gradient Boosting Decision Tree-GBDT）是梯度提升方法（GB）和决策树算法的结合，它是Boosting族中一个重要的算法，有很多简称，如GBT（Gradient Boosting Tree）, GTB（Gradient Tree Boosting ）， GBRT（Gradient Boosting Regression Tree）, MART(Multiple Additive Regression Tree)。基于梯度提升算法的学习器叫做GBM(Gradient Boosting Machine)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "疑问：\n",
    "1. 如何初始化弱学习器\n",
    "2. 如何理解负梯度的计算公式\n",
    "3. 如何利用$(x_i,r_{ti}) \\quad (i=1,2,...,m)$拟合一颗CART回归树"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GBDT回归算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GBDT回归算法流程（学习率$\\alpha=1$）\n",
    "GBDT使用的是M颗树组成的加法模型\n",
    "$$F(x,\\omega)=\\sum_{m=0}^M \\alpha_m h_m(x,\\omega_m)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输入：\n",
    "- 训练数据集$T={(x_1,y_1),(x_2,y_2),...,(x_N,y_N)}$，其中$x_i \\in \\chi \\subseteq R^n$，$y_i \\in Y \\subseteq R$\n",
    "- 损失函数$L(y,f(x))$\n",
    "\n",
    "输出：最终回归树$f_M$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 初始化弱学习器$f_0(x)$\n",
    "$$f_0(x)=arg \\ min_c \\sum_{i=1}^ML(y_i,c)$$\n",
    "    - 初始的弱学习器在笛卡尔坐标系下就是平行于x轴的一条直线\n",
    "2. $对m=1,2,...,M$  # 建立$M$颗回归树\n",
    "    1. 对$i=1,2,...,N$，计算第$m$颗树的响应值（损失函数的负梯度，即残差近似值）  \n",
    "    $$r_{mi}=-\\left [ \\frac{\\partial L(y_i,f(x_i))}{\\partial f(x_i)} \\right ] _{f(x)=f_{m-1}(x)}$$\n",
    "        - 对于平方损失函数，拟合的就是残差；对于一般损失函数，拟合的就是残差的近似值。（eg：**若采用平方损失函数$L(y_i,f(x_i))=\\frac{1}{2}(y_i-f(x_i))^2$，$r_{mi}=y_i-f(x_i)$，即残差**）\n",
    "    2. $对i=1,2,...,N$，使用CART回归树拟合数据$(x_i,r_{mj})$,得到第$m$颗回归树，其对应叶结点区域为$R_{mj}$， $j=1,2,...,J$，$J$为第$m$颗树的叶结点的总数。  \n",
    "        - **疑问：为何训练时要将$r_{mj}$作为标签值？**\n",
    "            - A：因为要拟合的就是真实值与当前模型预测值的残差\n",
    "        - 求回归树的方法：同CART回归树的生成方法\n",
    "    3. 对$J$个叶节点区域$j=1,2,...,J$，计算出使得拟合效果最好的参数$c_{mj}$ $$c_{mj}=arg \\ min_c \\sum_{x_i \\in R_{mj}}L(y_i,f_{m-1}(x_i)+c)$$\n",
    "        - **参数$c_{mj}$的含义**：若采用平方损失函数，对于第$m$颗树，为每个叶子节点分别赋一个参数$c_{mj}$，来拟合残差\n",
    "        - 求参数的方法：求一阶导数\n",
    "    4. 更新强学习器$$f_m(x)=f_{m-1}(x)+\\sum_{j=1}^J c_{mj}I(x \\in R_{mj})$$\n",
    "3. 得到强学习器$$f_M(x)=f_0(x)+\\sum_{m=1}^M\\sum_{j=1}^Jc_{mj}I(x \\in R_{mj})$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**小结**：\n",
    "- GBDT回归算法中，要预设的参数：\n",
    "    - 学习率（正则化项）\n",
    "    - CART树深度\n",
    "    - 迭代次数（基学习器总数）\n",
    "- GBDT回归算法中，要学习内容：\n",
    "    - 初始弱学习器\n",
    "    - 每轮迭代中要学习的内容：\n",
    "        - 第m个回归树（的结构，即叶结点区域）\n",
    "        - 第m个学习器的参数$c_{mj}, \\ j=1,2,...,J$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GBDT回归常用的损失函数\n",
    "sklearn实现了4种损失函数：\n",
    "- 平方误差（默认）：'ls'。适合噪音不多的情况。\n",
    "- 绝对值损失：'lad'。\n",
    "- Huber损失：'huber'。适合噪音较多的情况。\n",
    "- 分位数损失：'quantile'。适合需要对训练集分段预测时。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 平方误差$$L(y_i,f(x_i))=\\frac{1}{2}(y_i-f(x_i))^2$$\n",
    "对应的负梯度为$$y_i-f(x_i)$$\n",
    "\n",
    "2. 绝对值损失$$|y_i-f(x_i)|$$\n",
    "对应的负梯度为$$sign(y_i-f(x_i))$$\n",
    "\n",
    "3. Huber损失：它是均方差和绝对损失的折衷产物，对于远离中心的异常点，采用绝对损失，而中心附近的点采用均方差。这个界限一般用分位数点度量。使用过程中可能需要调整参数$\\delta$。$$L(y_i,f(x_i))=\\left\\{\\begin{matrix} \n",
    "  \\frac{1}{2}(y_i-f(x_i))^2，for \\ |y_i-f(x_i)|≤\\delta  \\\\  \n",
    "  \\delta |y_i-f(x_i)|-\\frac{1}{2} \\delta^2，\\ otherwise\n",
    "\\end{matrix}\\right. $$  \n",
    "对应的负梯度为$$r(y_i,f(x_i))=\\left\\{\\begin{matrix} \n",
    "  y_i-f(x_i),   for \\ |y_i-f(x_i)|≤\\delta\\\\  \n",
    "  \\delta·sign(y_i-f(x_i))，\\ otherwise\n",
    "\\end{matrix}\\right. $$  \n",
    "![](squared_lossand_and_Huber_loss.png)\n",
    "\n",
    "4. 分位数损失：对应的是分位数回归的损失函数$$L(y_i,f(x_i))=\\sum_{y_i≥f(x_i)}\\theta|y_i-f(x_i)|+\\sum_{y_i<f(x_i)}(1-\\theta)|y_i-f(x_i)|$$，$\\theta$为分位数，需要预先指定。对应的负梯度为\n",
    "$$r(y_i,f(x_i))=\\left\\{\\begin{matrix} \n",
    "  \\theta \\quad y_i≥f(x_i)\\\\  \n",
    "  \\theta-1 \\quad otherwise\n",
    "\\end{matrix}\\right. $$  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 正则化\n",
    "正则化有多种方法，下面介绍几种。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 早停法（Early Stopping）\n",
    "选择一部分样本作为验证集，在迭代拟合训练集的过程中，如果模型在验证集里错误率不再下降，就停止训练。可以用于控制迭代的轮数（树的个数）。**在sklearn的GBDT中可以设置参数n_iter_no_change实现early stopping**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shrinkage方法\n",
    "在这种方法中，对于前面的弱学习器的迭代：$$f(x)=f_{m-1}(x)+h_m(x)$$，加上一个正则化项$\\alpha$后，则有$$f(x)=f_{m-1}(x)+\\alpha h_m(x)$$，$\\alpha$也叫做学习率。学习率越小，所需的迭代次数也就越多。\n",
    "\n",
    "在**实际调参中推荐将learning_rate设置为一个小的常数（e.g. learning_rate <= 0.1），并通过early stopping机制来选n_estimators**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 子采样比例（Subsample）\n",
    "这种方法从训练集中进行不放回抽样（取值是$(0,1]$），对抽样的样本进行拟合。可以减小方差，但会增大偏差。**一般建议设置在$[0.5, 0.8]$**。\n",
    "\n",
    "**使用了子采样的GBDT有时也称作随机梯度提升树 (Stochastic Gradient Boosting Tree, SGBT)**。由于使用了子采样，程序可以通过采样分发到不同的任务去做Boosting的迭代过程，最后形成新树，从而克服弱学习器难以并行学习的弱点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 剪枝\n",
    "这一方法见CART的剪枝。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GBDT二分类算法\n",
    "**GBDT无论用于分类还是回归，一直使用的是CART回归树，不会因为我们所选择的任务是分类任务就选用分类树。**这是因为GBDT中每轮的训练是基于上一轮模型的的负梯度基础之上训练的。这要求真实标签与弱分类器的差是有意义的。如果采用分类树，则输出的是类别，类别与真实的标签类别相减没有意义。为了解决这个问题，有以下两种方法：\n",
    "\n",
    "1. 采用指数损失函数，此时GBDT将退化为AdaBoost，可以解决问题。 \n",
    "2. 使用类似于逻辑回归的对数似然损失函数，如此可以**通过结果的概率值与真实概率值的差距当做残差来拟合**（本文介绍对象）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 原理\n",
    "![](GBDT二分类的原理.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GBDT的调参\n",
    "在sacikit-learn中，GradientBoostingClassifier为GBDT分类算法对应类， 而GradientBoostingRegressor为GBDT回归算法对应类。两者的参数类型完全相同，除有些参数比如损失函数loss的可选项不同。\n",
    "\n",
    "GBDT的调参也分为Boosting框架参数和弱学习器参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GBDT类库的Boosting框架参数\n",
    "1. n_estimators: 弱学习器的最大迭代次数/最大的弱学习器的个数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，又容易过拟合，一般选择一个适中的数值。默认是100。在实际调参的过程中，常将n_estimators和下面介绍的参数learning_rate一起考虑。\n",
    "2. learning_rate: 即每个弱学习器的权重缩减系数$ν$，也称作步长/学习率/正则化项。之前介绍过，加上了正则化项，强学习器的迭代公式为$f_k(x)=f_{k−1}(x)+ν·h_k(x)$。$ν$的取值范围为$0<ν≤1$。对于同样的训练集，较小的ν意味着需要更多的弱学习器的迭代次数。因此参数n_estimators和learning_rate要一起调参。一般来说，**可以从一个小一点的$ν$开始调参，默认是1**。\n",
    "3. subsample: 子采样比例，取值为$(0,1]$。这里是不放回抽样。如果取值为1，则全部样本都使用，等于没有使用子采样。如果取值小于1，则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差，即防止过拟合，但是会增加样本拟合的偏差，因此取值不能太低。推荐在$[0.5, 0.8]$之间，**默认是1.0，即不使用子采样**。\n",
    "4. init: 初始化的弱学习器，即前面介绍的$f_0(x)$。**如果不输入，则用训练集样本来做样本集的初始化分类回归预测。否则用init参数提供的学习器做初始化分类回归预测。**一般用在我们对数据有先验知识，或者之前做过一些拟合的时候，如果没有的话就不用管这个参数了。\n",
    "5. loss: GBDT算法中的损失函数。分类模型和回归模型的损失函数是不一样的。\n",
    "    - 对于分类模型，有对数似然损失函数\"deviance\"和指数损失函数\"exponential\"两者输入选择。默认是对数似然损失函数\"deviance\"。一般来说，推荐使用默认的\"deviance\"。它对二元分离和多元分类各自都有比较好的优化。而使用指数损失函数等于回到了Adaboost算法。\n",
    "    - 对于回归模型，**有均方差\"ls\", 绝对损失\"lad\", Huber损失\"huber\"和分位数损失“quantile”。默认是均方差\"ls\"**。一般来说，若数据的噪点不多，用默认的均方差\"ls\"较好。若噪音点较多，则推荐用抗噪音的损失函数\"huber\"。而如果我们需要对训练集进行分段预测的时候，则采用“quantile”。\n",
    "6. alpha：这个参数只有GradientBoostingRegressor有，**当我们使用Huber损失\"huber\"和分位数损失“quantile”时，需要指定分位数的值。默认是0.9，如果噪音点较多，可以适当降低这个分位数的值。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GBDT类库的弱学习器参数\n",
    "GBDT使用CART作为基学习器，因此这类参数基本和DecisionTreeClassifier和DecisionTreeRegressor类似。这里省略。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GBDT回归类库的实例\n",
    "sklearn提供了`GradientBoostingRegressor`类以实现GBDT回归。\n",
    "\n",
    "### 导入数据集\n",
    "diabetes数据集基本信息：\n",
    "![](diabetes数据集基本信息.png)\n",
    "注：这10个特征变量均以均值为中心，并按标准差乘以n_samples进行缩放（即每列的平方和为1）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_diabetes\n",
    "\n",
    "X, y = load_diabetes(return_X_y=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据划分\n",
    "选取数据集90%作为训练集，其余作为测试集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 建立模型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "\n",
    "params = {'n_estimators': 500,  # 迭代次数\n",
    "          'max_depth': 4,  # 基回归树最大深度\n",
    "          'min_samples_split': 5,  # 基回归树内部节点再划分所需最小样本数\n",
    "          'learning_rate': 0.01,  # 学习率\n",
    "          'loss': 'ls'}  # 损失函数\n",
    "\n",
    "reg = GradientBoostingRegressor(**params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingRegressor(learning_rate=0.01, max_depth=4, min_samples_split=5,\n",
       "                          n_estimators=500)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_predict = reg.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集均方误差：3062.9143\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "mse = mean_squared_error(y_test, y_predict)\n",
    "print(\"测试集均方误差：{:.4f}\".format(mse))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 可视化\n",
    "\n",
    "**绘制每轮迭代后模型的偏差（这里使用均方误差）**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_staged_loss(params, reg):\n",
    "    test_score = np.zeros((params['n_estimators'], ), dtype=np.float64)  # 创建全0数组 以保存每次迭代后模型的MSE\n",
    "    for i, y_pred in enumerate(reg.staged_predict(X_test)):  # 获取每次迭代后模型的MSE 保存到数组\n",
    "        test_score[i] = reg.loss_(y_test, y_pred)  \n",
    "\n",
    "\n",
    "    fig = plt.figure(figsize=(6, 6))\n",
    "    plt.subplot(1, 1, 1)\n",
    "    plt.title('Deviance')    \n",
    "    plt.plot(np.arange(params['n_estimators']) + 1, reg.train_score_, 'b-',\n",
    "             label='Trainicce Set Deviance')  # reg.train_score_属性保存了每次迭代后训练集的损失\n",
    "    plt.plot(np.arange(params['n_estimators']) + 1, test_score, 'r-',\n",
    "             label='Test Set Deviance')\n",
    "    plt.legend(loc='upper right')  # 图例位置\n",
    "    plt.xlabel('Boosting Iterations')  \n",
    "    plt.ylabel('Deviance')\n",
    "    fig.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "plot_staged_loss(params, reg)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 根据上图我们可以得知，迭代次数在150次左右时，模型在测试集上的损失值基本不变，即模型基本收敛。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 调参\n",
    "1. 其他参数不变，减小迭代次数n_estimators到150\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集均方误差：3072.4087\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAGoCAYAAAATsnHAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAABTk0lEQVR4nO3dd3gU1ffH8fchQKjSUQQUVESpASNSvipKVwRUlGJBLNhF+KGAvWBHsBdUBDsIUmxIEQVFEVCkI1VFEFC6SM39/XEnGCAJm2Q3u0k+r+fZJ9m7M5Ozq+Hkztw5x5xziIiIxJp80Q5AREQkNUpQIiISk5SgREQkJilBiYhITFKCEhGRmKQEJSIiMUkJSiRGmdlxZrbDzOKiHYtINChBiWSRma02s3/NbLuZbTGzGWZ2g5ll6ffLOfebc66Yc25/uGIVyUmUoETC4wLnXHHgeOBxoC/wRnRDEsnZlKBEwsg5t9U5Nx7oBHQzs1pmFm9mA83sNzNbb2avmFlhADNbbGZtk/c3s/xm9peZ1TezKmbmzCx/8Fr3YPvtZrbSzK5PsV9TM1tjZv9nZhvMbJ2ZdU/xemEze9rMfjWzrWb2TYoYGgazvi1m9rOZNc2eT0skfUpQIhHgnPsBWAOcCTwBnAwkACcBFYH7gk3fB7qk2LUV8Jdz7sdUDrsBaAscBXQHBptZ/RSvHwOUCI5/DfCimZUKXhsInAY0BkoDdwJJZlYR+BQYEIz3AUabWbnMvneRcFGCEomctfh/9K8DejnnNjnntgOPAp2Dbd4D2plZkeB512DsMM65T51zK5z3NTARnwCT7QUecs7tdc59BuwAqgfXwq4Gejrn/nDO7XfOzXDO7QYuBz5zzn3mnEtyzk0CZgPnhfFzEMmU/NEOQCQXq4j/HSsCzDGz5HED4gCcc8vNbDFwgZl9DLQD6qV2MDNrA9yPn43lC447P8Umfzvn9qV4vhMoBpQFCgErUjns8cAlZnZBirECwNTQ36ZIZChBiUSAmZ2OT1Bj8Qsmajrn/khj8+TTfPmARc655akcLx4YDVwJjHPO7TWzsfhkdyR/AbuAE4GfD3ntd+Bt59x1IRxHJFvpFJ9IGJnZUcGihw+Ad5xzPwOv4a8XlQ+2qWhmrVLs9gHQEriRNE7vAQWBeGAjsC+YTbUMJSbnXBIwFBhkZseaWZyZNQqS3jv42VurYLxQsOCiUobfvEiYKUGJhMfHZrYdPyO5GxiEX8gAfga1HPjezLYBk4HqyTs659YB3+EXMIxI7eDBtavbgJHAZvy1qvEZiK8P/nTgLGATfuFGPufc70B74C588vsduAP92yAxwNSwUEREYpH+ShIRkZikBCUiIjFJCUpERGKSEpSIiMSkXHkfVNmyZV2VKlWiHYaIiIRgzpw5fznnDiuvlSsTVJUqVZg9e3a0wxARkRCY2a+pjesUn4iIxCQlKBERiUlKUCIiEpNy5TUoEcm6vXv3smbNGnbt2hXtUCSXKFSoEJUqVaJAgQIhba8EJSKpWrNmDcWLF6dKlSqkaBUikinOOf7++2/WrFlD1apVQ9onoqf4zKykmY0ysyVBq+pGZlbazCaZ2bLga6lgWzOz58xsuZnNS9kp1My6BdsvM7NukYxZRLxdu3ZRpkwZJScJCzOjTJkyGZqRR/oa1LPABOfcKUBdYDHQD5jinKsGTAmeA7QBqgWPHsDLAGZWGt+k7QygAXB/ijbWIhJBSk4SThn9/yliCcrMjgLOAt4AcM7tcc5twZf2Hx5sNhzoEHzfHngraGf9PVDSzCoArYBJQbvszcAkoHWk4hYRkdgQyRnUCfj+Mm+a2U9m9rqZFQWODvrfJPfBKR9sXxHfiybZmmAsrfGDmFkPM5ttZrM3btwY/ncjItnq77//JiEhgYSEBI455hgqVqx44PmePXvS3Xf27NncdtttR/wZjRs3Dle4hxk6dCi1a9emTp061KpVi3HjxqW7/dixY1m0aFGqrz3wwAMH3n+1atW46KKL0tw2FNdee22W9s8ukVwkkR+oD9zqnJtpZs/y3+m81KQ293PpjB884NwQYAhAYmKimlyJ5HBlypRh7ty5gP8HulixYvTp0+fA6/v27SN//tT/CUtMTCQxMfGIP2PGjBlhifVQa9as4ZFHHuHHH3+kRIkS7NixgyP94Tx27Fjatm1LjRo1Un29V69eB97/iBEjOPfcc5k/fz7lyh1WIeiIXn/99QzvEw2RnEGtAdY452YGz0fhE9b64NQdwdcNKbavnGL/SsDadMZFJI+56qqr6N27N+eccw59+/blhx9+oHHjxtSrV4/GjRuzdOlSAL766ivatm0L+OR29dVX07RpU0444QSee+65A8crVqzYge+ffPJJateuTd26denXz/8tvXz5cpo3b07dunWpX78+K1asAOCpp57i9NNPp06dOtx///2HxblhwwaKFy9+4PjFihU7sHJtxYoVtG7dmtNOO40zzzyTJUuWMGPGDMaPH88dd9xBQkLCgZ+Tlk6dOtGyZUvee+89AObMmcPZZ5/NaaedRqtWrVi3bh2LFy+mQYMGB/ZZvXo1derUAaBp06YHysHdeOONJCYmUrNmzYPeS5UqVbj//vupX78+tWvXZsmSJQDs2LGD7t27H5gdjh49GoCJEyfSqFEj6tevzyWXXMKOHTvSfQ+hiNgMyjn3p5n9bmbVnXNLgWbAouDRDXg8+Jo87x0P3GJmH+AXRGx1zq0zsy+AR1MsjGgJ9I9U3CJyuNtvh2AyEzYJCfDMMxnf75dffmHy5MnExcWxbds2pk2bRv78+Zk8eTJ33XXXgX8wU1qyZAlTp05l+/btVK9enRtvvPGge3E+//xzxo4dy8yZMylSpAibNm0C4LLLLqNfv35ceOGF7Nq1i6SkJCZOnMiyZcv44YcfcM7Rrl07pk2bxllnnXXgeHXr1uXoo4+matWqNGvWjIsuuogLLrgAgB49evDKK69QrVo1Zs6cyU033cSXX35Ju3btaNu2LR07dgzpc6hfvz5Llixh79693HrrrYwbN45y5coxYsQI7r77boYOHcqePXtYuXIlJ5xwAiNGjODSSy897DiPPPIIpUuXZv/+/TRr1ox58+YdSGRly5blxx9/5KWXXmLgwIG8/vrrPPzww5QoUYL58+cDsHnzZv766y8GDBjA5MmTKVq0KE888QSDBg3ivvvuC/G/auoifR/UrcC7ZlYQWAl0x8/aRprZNcBvwCXBtp8B5wHLgZ3BtjjnNpnZw8CsYLuHnHObIhy3iMSoSy65hLi4OAC2bt1Kt27dWLZsGWbG3r17U93n/PPPJz4+nvj4eMqXL8/69eupVKnSgdcnT55M9+7dKVKkCAClS5dm+/bt/PHHH1x44YWAv8kU/Exh4sSJ1KtXD/AzimXLlh2UoOLi4pgwYQKzZs1iypQp9OrVizlz5tCnTx9mzJjBJZdccmDb3bt3Z+pzcM5fyVi6dCkLFiygRYsWAOzfv58KFSoAcOmllzJy5Ej69evHiBEjGDFixGHHGTlyJEOGDGHfvn2sW7eORYsWHUhQF110EQCnnXYaH3300YHP6oMPPjiwf6lSpfjkk09YtGgRTZo0AWDPnj00atQoU+8rpYgmKOfcXCC1E8HNUtnWATencZyhwNCwBncEzoFW2Ip4mZnpRErRokUPfH/vvfdyzjnnMGbMGFavXk3Tpk1T3Sc+Pv7A93Fxcezbt++g151zhy2BTk4Ah3LO0b9/f66//vp04zQzGjRoQIMGDWjRogXdu3end+/elCxZ8sC1taz46aefSExMxDlHzZo1+e677w7bplOnTlxyySVcdNFFmBnVqlU76PVVq1YxcOBAZs2aRalSpbjqqqsOuk8p+XNL+Zml9Vm1aNGC999/P8vvKyXV4ktFt25w1VXRjkJEjmTr1q1UrOgX9Q4bNizTx2nZsiVDhw5l586dAGzatImjjjqKSpUqMXbsWMDPdHbu3EmrVq0YOnTogWssf/zxBxs2bDjoeGvXruXHH3888Hzu3Lkcf/zxHHXUUVStWpUPP/wQ8P+w//zzzwAUL16c7du3hxTv6NGjmThxIl26dKF69eps3LjxQILau3cvCxcuBODEE08kLi6Ohx9+mE6dOh12nG3btlG0aFFKlCjB+vXr+fzzz0P6rF544YUDzzdv3kzDhg359ttvWb58OQA7d+7kl19+Cem9pEcJKhXFisHIkbB1a7QjEZH03HnnnfTv358mTZqwf//+TB+ndevWtGvXjsTERBISEhg4cCAAb7/9Ns899xx16tShcePG/Pnnn7Rs2ZKuXbvSqFEjateuTceOHQ9LLHv37qVPnz6ccsopJCQkMGLECJ599lkA3n33Xd544w3q1q1LzZo1Dyw/79y5M0899RT16tVLdZHE4MGDDywzf+edd/jyyy8pV64cBQsWZNSoUfTt25e6deuSkJBw0OrETp068c4776R6/alu3brUq1ePmjVrcvXVVx84RZeee+65h82bN1OrVi3q1q3L1KlTKVeuHMOGDaNLly7UqVOHhg0bHlhUkRWW1jQ2J0tMTHRZaVg4axY0aACvvgo9eoQxMJEcZPHixZx66qnRDkNymdT+vzKzOc65wy4HaQaVisREqFEDsnDGQEREskgJKhVm/hrUd99BcFuFiIhkMyWoNFx+OcTFwfDhR95WRETCTwkqDRUqQOvW8NZbkIVrryIikklKUOm46ir44w+YPDnakYiI5D1KUOm44AIoXVqLJUREokEJKh3x8dC1K4wZA1u2RDsakbwlK+02wBeMTata+fr162nbti1169alRo0anHfeeekea8uWLbz00ktpvh4XF0dCQgI1a9akbt26DBo0iKSkpCPGmJpQW4XkBZGuxZfjXXUVvPACjBgBR6hsIiJhdKR2G0fy1VdfUaxYsVR7Pt133320aNGCnj17AjBv3rx0j5WcoG666aZUXy9cuPCBWDds2EDXrl3ZunUrDz74YMjxJgu1VUheoBnUEdSvD7Vq6TSfSCxIra0EwHPPPUeNGjWoU6cOnTt3ZvXq1bzyyisHqi9Mnz79oOOsW7fuoGKxycVRIfVWGv369WPFihUkJCRwxx13pBtj+fLlGTJkCC+88ALOOfbv388dd9xx4Jivvvoq4Cs8fPbZZwf2u+qqqxg9evRBrULSaicybNgwLrroIlq3bk21atW48847DxxnwoQJ1K9fn7p169KsmS97+s8//3D11Vdz+umnU69evSM2T4wVmkEdQfI9UX36wOLFoBvrJU+KgX4bzrk020o8/vjjrFq1ivj4eLZs2ULJkiW54YYb0px13XzzzXTq1IkXXniB5s2b0717d4499tg0W2k8/vjjLFiwIOQiryeccAJJSUls2LCBcePGUaJECWbNmsXu3btp0qQJLVu2pHPnzowYMYLzzjuPPXv2MGXKFF5++WVmzpx54DinnHJKmu1E5s6dy08//UR8fDzVq1fn1ltvpVChQlx33XVMmzaNqlWrHmgb8sgjj3DuuecydOhQtmzZQoMGDWjevPlBhXdjkRJUCK64Avr3h9dfh6efjnY0InnT7t2702wrUadOHS677DI6dOhAhw4djnisVq1asXLlSiZMmMDnn39OvXr1WLBgQZqtNI477rgMx5tcRm7ixInMmzePUaNGAb7A7bJly2jTpg233XYbu3fvZsKECZx11lkULlz4oGOk106kWbNmlChRAoAaNWrw66+/snnzZs4666wDzRFLly59IIbx48cfqDG4a9cufvvtt5gvZaUEFYLy5aFDB3/T7qOP+sUTInlKDPTbSK+txKeffsq0adMYP348Dz/88IFq3ukpXbo0Xbt2pWvXrrRt25Zp06al2Upj9erVGYp15cqVxMXFUb58eZxzPP/887Rq1eqw7Zo2bcoXX3zBiBEj6NKly2Gvp9dOJLUWIqm1wgD/2Y0ePZrq1atn6H1Em65Bhei66+Dvv/2KPhHJfvHx8am2lUhKSuL333/nnHPO4cknn2TLli3s2LEj3fYVX3755YHWGtu3b2fFihUcd9xxabbSyEgrjI0bN3LDDTdwyy23YGa0atWKl19++cDs55dffuGff/4BfAXzN998k+nTp6eawDLaTqRRo0Z8/fXXrFq1CuDAKb5WrVrx/PPPH5jV/fTTTyG9l2hTggpRs2ZQtSoMGRLtSETypnz58qXaVmL//v1cfvnl1K5dm3r16tGrVy9KlizJBRdcwJgxY1JdJDFnzhwSExOpU6cOjRo14tprr+X0009Ps5VGmTJlaNKkCbVq1Up1kcS///57YJl58+bNadmy5YEFFtdeey01atSgfv361KpVi+uvv/5A87+WLVsybdo0mjdvTsGCBQ87bkbbiZQrV44hQ4Zw0UUXUbdu3QM9oO6991727t1LnTp1qFWrFvfee2+GP/9oULuNDHj0Ubj7bli2DE46KeyHF4kparchkaB2GxHSvbsvIPv669GOREQk91OCyoAKFXz5ozffhBBuZBcRkSxQgsqg666DDRvg44+jHYlI5OXGSwASPRn9/0kJKoNatYLKleG116IdiUhkFSpUiL///ltJSsLCOcfff/9NoUKFQt5H90FlUFwcXHMNPPggrF4NVapEOyKRyKhUqRJr1qxh48aN0Q5FcolChQodVGLqSJSgMuHqq+Ghh+CNN+Dhh6MdjUhkFChQ4EBFApFo0Cm+TKhcGdq0gaFDIbidQUREwkwJKpOuuw7WroUUxYhFRCSMlKAy6fzz/bJzLZYQEYkMJahMyp/fX4v67DNYsyba0YiI5D5KUFlwzTWQlOSvRYmISHgpQWVB1arQsqUvfaTFEiIi4aUElUU33gi//w6ffBLtSEREchclqCxq29YvO3/xxWhHIiKSuyhBZVH+/HDDDTB5MixZEu1oRERyDyWoMLj2WihYEF56KdqRiIjkHhFNUGa22szmm9lcM5sdjD1gZn8EY3PN7LwU2/c3s+VmttTMWqUYbx2MLTezfpGMOTPKl4dLLoHhwyHoFC0iIlmUHTOoc5xzCYd0SxwcjCU45z4DMLMaQGegJtAaeMnM4swsDngRaAPUALoE28aUm2+GbdvgnXeiHYmISO4QS6f42gMfOOd2O+dWAcuBBsFjuXNupXNuD/BBsG1MadgQ6tXziyXUnUBEJOsinaAcMNHM5phZjxTjt5jZPDMbamalgrGKwO8ptlkTjKU1fhAz62Fms81sdjTaA5j5WdSCBTB9erb/eBGRXCfSCaqJc64+/vTczWZ2FvAycCKQAKwDng62tVT2d+mMHzzg3BDnXKJzLrFcuXLhiD3DunSBUqXghRei8uNFRHKViCYo59za4OsGYAzQwDm33jm33zmXBLyGP4UHfmZUOcXulYC16YzHnCJFfH2+MWN8pXMREcm8iCUoMytqZsWTvwdaAgvMrEKKzS4EFgTfjwc6m1m8mVUFqgE/ALOAamZW1cwK4hdSjI9U3Fl1442wfz8MGRLtSEREcrZIdtQ9GhhjZsk/5z3n3AQze9vMEvCn6VYD1wM45xaa2UhgEbAPuNk5tx/AzG4BvgDigKHOuYURjDtLTjwRWrf2Ceruu6FAgWhHJCKSM5nLhUvOEhMT3ezZs6P28z/91JdAGjECLr00amGIiOQIZjbnkFuRgNhaZp5rtG7tK51rsYSISOYpQUVAXJy/FjV9OsyfH+1oRERyJiWoCLn6aihUCJ5/PtqRiIjkTEpQEVKmDFxxBbz9Nvz9d7SjERHJeZSgIqhnT9i1C159NdqRiIjkPEpQEVSzJrRo4evz7dkT7WhERHIWJajU/PwzfPllWA51++2+qsSoUWE5nIhInqEElZoePXyb3KSkLB+qdWuoXh0GD1aVcxGRjFCCSk3v3rBsGXzySZYPlS+fvxY1ezZ8910YYhMRySOUoFJz8cVw3HHw9NNH3jYEV14JJUv6WZSIiIRGCSo1+fP7ac+0aX7qk0VFi/qzhh99BL/+Gob4RETyACWotFx7LRQvDoMGheVwt9zimxqq/JGISGiUoNJy1FF+2jNyJPzyS5YPV7kydOwIr70G27eHIT4RkVxOCSo9d9wB8fHwwANhOVyvXrB1K7zxRlgOJyKSqylBpefoo+G22+CDD8JS9fWMM+DMM+GZZ2DfvqyHJyKSmylBHckdd/hrUffdF5bD/d//+YUSo0eH5XAiIrmWEtSRlC4NffrA2LEwa1aWD3fBBVCtGgwcqBt3RUTSowQVip49fXnye+7J8qHy5fP3Ac+e7ftFiYhI6pSgQnHUUdCvH0yc6O+NyqIrr4SyZf0sSkREUqcEFaqbboIKFeDuu7N8bq5IEbj5Zvj4Y1i6NEzxiYjkMkpQoSpSxCenb76BL77I8uFuusmvYA/TfcAiIrmOElRGXHedr9F3331ZnkWVLw/dusHw4bBhQ5jiExHJRZSgMqJgQbj3Xr+a79NPs3y43r19I8Pnnw9DbCIiuYwSVEZ16wYnnBCWWVT16nDhhb4+37ZtYYpPRCSXUILKqAIFfHL66Sd/b1QW9e8PW7bAq69m+VAiIrmKuVx4t2hiYqKbHYY2GWnatw9q1vSrHObO9Tc3ZUHLlr6S0qpVUKhQeEIUEckpzGyOcy7x0HHNoDIjf364/36fVUaNyvLh+veHP/+EYcOyHpqISG6hGVRm7d8Pder461Dz50NcXKYP5Rw0bgzr1/vOHvnzhzFOEZEYpxlUuMXF+TYcixfDiBFZOpSZn0WtWpXlQ4mI5BqaQWVFUhIkJMC//8LChX4ZehYOVbeun03Nm5fly1oiIjmGZlCRkC8fPPYYLF8Or7yS5UP16+fz3CefhCk+EZEcTDOorHIOWrTwy86XL4dSpTJ9qH374OSTfZWJ777zp/5ERHI7zaAixcyXJd+8GR55JEuHyp8f7rwTZs6Er74KT3giIjlVRBOUma02s/lmNtfMZgdjpc1skpktC76WCsbNzJ4zs+VmNs/M6qc4Trdg+2Vm1i2SMWdKQoKvMPH887ByZZYOddVVcMwx8OijYYlMRCTHyo4Z1DnOuYQU07d+wBTnXDVgSvAcoA1QLXj0AF4Gn9CA+4EzgAbA/clJLaYMGOCnQP37Z+kwhQr5Gn2TJ4elga+ISI4VjVN87YHhwffDgQ4pxt9y3vdASTOrALQCJjnnNjnnNgOTgNbZHPORVazoW8OPHOkvIGXBDTdAyZJ+/YWISF4V6QTlgIlmNsfMegRjRzvn1gEEX8sH4xWB31PsuyYYS2s89txxhz8/17t3lgrJFi8Ot94KY8bAggVhjE9EJAeJdIJq4pyrjz99d7OZnZXOtqmtWXPpjB+8s1kPM5ttZrM3btyYuWizqlgxePhh+P77LN9x27OnT1QPPRSm2EREcpiIJijn3Nrg6wZgDP4a0vrg1B3B1+R2fWuAyil2rwSsTWf80J81xDmX6JxLLFeuXLjfSui6d4d69fxs6p9/Mn2YMmXgttvgww81ixKRvCliCcrMippZ8eTvgZbAAmA8kLwSrxswLvh+PHBlsJqvIbA1OAX4BdDSzEoFiyNaBmOxKS7Or+ZbsybLS/F699YsSkTyrkjOoI4GvjGzn4EfgE+dcxOAx4EWZrYMaBE8B/gMWAksB14DbgJwzm0CHgZmBY+HgrHY1aQJXH65vz9qxYpMH6Z0aX+q78MPfT1aEZG8RJUkImXtWt8y95xzYPz4TB9m0yaoWtX3jPrwwzDGJyISI1RJIrsdeyzcey98/DF8/nmmD5M8ixo1SrMoEclbNIOKpD17oHZt//38+Zmudr55M1Sp4kv+haE/oohITNEMKhoKFoRnn/VdCJ95JtOHKVUKbr8dRo/2rThERPICJahIa90a2reHBx+E1aszfZjbb4ejjtKKPhHJO5SgssPzz/uGTzfemOkKEylnUT//HN7wRERikRJUdqhc2bfimDAhSxUmevWCEiU0ixKRvEEJKrvcfDOcfrpfkrcpc7dxlSzpZ1EffaRZlIjkfkpQ2SUuDl57Df7+G/r2zfRhbr/dz6IeeCBskYmIxCQlqOxUty783//B66/D119n6hAlS/pDjB0LP/wQ1uhERGKK7oPKbjt3Qq1afgn63Lm+Q2EGbd8OJ57o892kSeEPUUQkO+k+qFhRpAi88gosXZrpjoTFi8Ndd/muu19+Geb4RERihBJUNLRs6YvJPvYYLFqUqUPccINfHHjXXVnqjSgiErOUoKJl0CA/FerRA5KSMrx7oUJw//0wc2aWatGKiMQsJahoKVfOJ6lvv/Wn/DKhWzc4+WS4+27Yvz/M8YmIRJkSVDRdeaU/3XfnnbByZYZ3z5/fd5hfuBDefz8C8YmIRJESVDSZ+SXncXFw9dWZOtXXsaPvMH/ffb54uohIbqEEFW2VK8Pgwf6+qBdfzPDu+fL5KkqrVsEbb0QgPhGRKNF9ULHAOWjTBmbM8MvPK1TI8O5nnw3Ll/tHkSIRilNEJAJ0H1QsM4MXXoDdu6FPn0zt/uijsG6dL5wuIpIbKEHFipNO8jX63nsPvvoqw7v/739w3nnwxBOwZUvYoxMRyXZKULGkf3/f2/3662HbtgzvPmCAbw//xBPhD01EJLspQcWSwoVh2DBYsQKuuirDq/rq1fMFKgYPhl9/jUiEIiLZRgkq1px9Njz1FIwZA48/nuHdH33UX5O6664IxCYiko2UoGLR7bdD165wzz0Zvh5VuTL07u0vZakdh4jkZFpmHqv++Qfq1/dff/4ZypQJedft2/2ai5NPhmnT/IxKRCRWaZl5TlO0qK9ftGEDXHNNhkqWFy8ODz0E33zjzxSKiORESlCxrH59vyRv3DhfEikDrrkGatTwK9dVAklEciIlqFjXsyc0a+YvLK1eHfJu+fPDwIG+ssRLL0UuPBGRSFGCinX58vkie2YZLijbujW0aOFP923aFMEYRUQiQAkqJzj+eN87aupUXxIpRGZ+FrVli7+JV0QkJ1GCyimuuQbOP9/3jpo3L+Td6tTxE68XXvCn+0REcgolqJzCDN58E0qVgi5dYOfOkHd9+GEoWBD69YtgfCIiYaYElZOUKwfDh8OiRRmqel6hgp94jR7t74sSEckJlKBympYtfXJ6+WUYOzbk3fr08VUmevaE/fsjF56ISLhEPEGZWZyZ/WRmnwTPh5nZKjObGzwSgnEzs+fMbLmZzTOz+imO0c3MlgWPbpGOOeY98oi/R+qaa2DNmpB2KVLEl/ibOxeGDo1seCIi4ZAdM6iewOJDxu5wziUEj7nBWBugWvDoAbwMYGalgfuBM4AGwP1mViob4o5dBQv6KhO7d8OVV4Y8Jbr0Ut836u671TNKRGJfRBOUmVUCzgdCKYPQHnjLed8DJc2sAtAKmOSc2+Sc2wxMAlpHLOic4uSTffvcqVPhySdD2sUMnn0W/vrLL5wQEYllkZ5BPQPcCRx6d+kjwWm8wWYWH4xVBH5Psc2aYCyt8YOYWQ8zm21mszdu3Biu+GPbVVdBp05w770wc2ZIuySfGXzuOVi6NLLhiYhkRcQSlJm1BTY45+Yc8lJ/4BTgdKA00Dd5l1QO49IZP3jAuSHOuUTnXGK5cuUyH3hOYgavvAKVKvn2HCF24R0wwF+T6t07wvGJiGRBJGdQTYB2ZrYa+AA418zecc6tC07j7QbexF9XAj8zqpxi/0rA2nTGBaBkSXj3XV+n75ZbQtrl6KPhvvvgs8/8Q0QkFkUsQTnn+jvnKjnnqgCdgS+dc5cH15UwMwM6AAuCXcYDVwar+RoCW51z64AvgJZmVipYHNEyGJNkTZr4jPP22z5ZheDWW/1lrJ49/VoLEZFYE437oN41s/nAfKAskFwl7jNgJbAceA24CcA5twl4GJgVPB4KxiSlu+/2S/RuvBFWrDji5gUL+jUWy5f7en0iIrFGHXVzk99+g4QEqFgRZszwnQuPoGNHf5pv0SKoUiXiEYqIHEYddfOC446DkSN9tunWLaTWHIMG+bUWvXplQ3wiIhmgBJXbNG8OTz/te70/9NARNz/uOL9KfexY+PzzyIcnIhIqneLLjZzzPTaGDYNRo+Dii9PdfM8e35Zj3z5YsAAKFcqeMEVEQKf48pbk+6MaNvSlkI7QPyp5wcSKFVowISKxQwkqt4qPh48+8v2j2rWD9evT3bxFC7jkEl+HdvXq7AlRRCQ9SlC5WYUKMG4cbNgAHTrAv/+mu/nTT0O+fHD77dkSnYhIupSgcrvTToN33oHvv/fXpdK55li5sr/fd9w4VZgQkehTgsoLLroIHnsMPvgAXngh3U179YLq1eG222DXrmyKT0QkFUpQeUXfvtC2rW+t++OPaW5WsCC8+KJfMDFgQJqbiYhEnBJUXmHml52XL+9bdGzdmuamzZr5+3yfeOKICwBFRCJGCSovKVMG3nvPL9Pr0CHdc3hPP+0XAF57bcgNe0VEwkoJKq8580w/k/rqK+jc2d+dm4oyZXxTw1mz/D1SIiLZTQkqL7rsMp91xo2D665Ls2Zfp05w/vm+ULrujRKR7KYElVfdcgs88ICfTd1xR6rLz83gpZf8vVE33JDuCnURkbBTgsrL7rvPdy4cNMgvQ0/Fccf5l774IuReiCIiYaEElZeZwTPP+FN+d9/t6/el4sYboVEjX2Fi48ZsjVBE8jAlqLwuXz54801/semmm2DEiMM2iYuD116DbdvUN0pEsk/ICcrMCptZ9UgGI1FSoIBvdNikCVxxhT+fd4iaNeGuu/xpPvWNEpHsEFKCMrMLgLnAhOB5gpmNj2Bckt2KFIGPP4YaNXxppO++O2yT/v3h1FP9gokdO6IQo4jkKaHOoB4AGgBbAJxzc4EqkQhIoqhkST97OvZYf8rvkJJI8fHw+uvw++9wzz3RCVFE8o5QE9Q+51zatXEk9zj6aJg4EYoX9zWPZs066OXGjf2lqueeg5kzoxSjiOQJoSaoBWbWFYgzs2pm9jwwI4JxSTRVrQpff+1rHTVvfliSevRRqFjRl0HavTtKMYpIrhdqgroVqAnsBt4DtgK3RygmiQVVqvgkVbo0XHAB/PbbgZeOOsqvSF+wAB58MHohikjuZi4XlgdITEx0s2fPjnYYucOiRf4mqOOPh2++8dkpcO21foX69On+1J+ISGaY2RznXOKh46Gu4ptkZiVTPC9lZoevRZbcp0YNGDXKJ6qLLz6oAvqgQb7SRLdu8M8/UYxRRHKlUE/xlXXObUl+4pzbDJSPSEQSe1q0gKFDYfJkuPRS2LsX8JOpYcN8c8M774xuiCKS+4SaoJLM7LjkJ2Z2PJD7zg1K2q680leO/fhjP2UKTg2ffbavLvHSS6ne3ysikmn5Q9zubuAbM/s6eH4W0CMyIUnMuvFG2LLFl5SoUwf69QPgkUdgwgS4+mq/cKJUqeiGKSK5Q0gzKOfcBKA+MAIYCZzmnNPfy3lRv36+0eFdd/msBBQqBG+9BRs2+C4eIiLhkJFisfHAJvwS8xpmdlZkQpKYZubLSdSu7RPV9OkAnHYa3Huv7yj/4YdRjlFEcoWQlpmb2RNAJ2AhkNx+1Tnn2kUwtkzTMvNs8Ntv0LIlrFrlp0+dOrF3r683u3IlzJ8PFSpEO0gRyQnSWmYe6jWoDkB155zqBoh33HEwYwZ06OBnUtu3U+Daa3nrLahXz3eS//hjP+ESEcmMUE/xrQQKRDIQyYFKl/Z1+9q0gR494P33OeUUePxx+PRTeOONaAcoIjlZqDOoncBcM5uCL3cEgHPutohEJTlHoUIwejScd57vJVWgALfe2pFx4/zy82bNfGk/EZGMCnUGNR54GF8gdk6KxxGZWZyZ/WRmnwTPq5rZTDNbZmYjzKxgMB4fPF8evF4lxTH6B+NLzaxVBt6fZIfChWH8eDjjDLj0UvINeYVhw3yz3m7dYP/+aAcoIjlRqMvMh6f2CPFn9AQWp3j+BDDYOVcN2AxcE4xfA2x2zp0EDA62w8xqAJ3xxWpbAy+ZWVyIP1uyS/HiMGmSn0ndeCPHvXYvLzzvmD4dBgyIdnAikhOFWouvmpmNMrNFZrYy+RHCfpWA84HXg+cGnAuMCjYZjl+AAdA+eE7werNg+/bAB8653c65VcByfPNEiTVFisCYMf6O3QEDuOLTzlzTZScPPeQLo4uIZESop/jeBF4G9gHnAG8Bb4ew3zPAnfy3NL0MsMU5ty94vgaoGHxfEfgdIHh9a7D9gfFU9jnAzHqY2Wwzm71x48YQ35aEXYEC/j6pJ5+EDz/k1V+aUr/KJrp2Bf1nEZGMCDVBFXbOTcHfN/Wrc+4B/EwoTWbWFtjgnEt5rSq1RcfuCK+lt89/A84Ncc4lOucSy5Url15oEmlmcMcd8NFHxM3/ma8LNmf/xk1cdRUkJR1xbxERIPQEtcvM8gHLzOwWM7uQI1czbwK0M7PVwAf4hPYMUNLMklcPVgLWBt+vASoDBK+XwFeuODCeyj4Syzp0gLFjKbJqEfOPbsaszzYweHC0gxKRnCLUBHU7UAS4DTgNuALolt4Ozrn+zrlKzrkq+EUOXzrnLgOmAh2DzboB44Lvx6c4ZsdgexeMdw5W+VUFqgE/hBi3RFubNjB2LGX/Xsq8oo14o+8vh3aQFxFJVair+GY553Y459Y457o75y5yzn2fyZ/ZF+htZsvx15iSb+d8AygTjPcG+gU/eyG+QO0iYAJws3NOC5dzktatsalTKV94O9+4xjzRfgZbt0Y7KBGJdenW4jOzZ5xzt5vZx6R+3Ue1+CR0K1bwb9PWsGYNLzV+h97fXKxSSCKS6Vp8ySv1BoY/JMlzTjyRwj99x5rT2tFrxiV8c/lLnPnuDdGOSkRiVLoJKsUKvNLAZyoWK1lWtizHLprCD1Uu5cz3buS3OiU4rm+XaEclIjEo1EUS7YBfzOxtMzs/xSo8kQzLV7QwVWeNZEaBs6nQ70p2jfk82iGJSAwKdZFEd+Ak4EOgK7DCzF6PZGCSux1dpTC7PxzHfGoT17EDjBp1xH1EJG8JuaOuc24v8Dn+nqY5+BJEIpl2TvsSfN57Mj8kJeIuvRRefBFCaKApInlDqLX4WpvZMHwdvI742nrqlypZ1u/J0jzZfBKf0hZuuQU6doT166MdlojEgFBnUFcBY4GTnXPdnHOfpainJ5JpcXHw5ogi3H78GB456gncp59CzZowdWq0QxORKAv1GlRn4CfgTAAzK2xmxSMZmOQdpUvD6LFxPLL3Tq6s+SOu/NHQqhV88EG0QxORKAr1FN91+BYYrwZDlfAzKpGwqFvXF0F/58ca9D/zG2jUCLp0gUGDoh2aiERJqMvFb8b3YJoJ4JxbZmZHKhYrkiFdu8KsWfDEM6Wo88YXdC1/Bfzf/8GaNTBwoG/RKyJ5RqgJardzbo8FdWmC+6C03ErC7skn4aef4JqbC3HqNyOoV7E3DB4Mf/wBb70F8fHRDlFEskmof5J+bWZ3AYXNrAX+fqiPIxeW5FUFCsDIkVC2LFzUMR9/3zMYnnrKD7ZqBVu2RDtEEckmoSaofsBGYD5wPfAZcE+kgpK8rXx5GD0a1q6FLl2N/b36wLvvwowZcNZZas0rkkeEuoovCb8o4ibnXEfn3GsuvTLoIlnUoAG89BJMmgT33IO/QPXZZ7BsGbRoAZs2RTtEEYmwdBOUeQ+Y2V/AEmCpmW00s/uyJzzJy665Bq6/Hh5/PKiE1Lw5jBsHixdDy5b+upSI5FpHmkHdjm/dfrpzroxzrjRwBtDEzHpFOjiRZ5/1K867dYMff8Qnpo8+8kmqdm348MNohygiEXKkBHUl0MU5typ5wDm3Erg8eE0kouLjYcwYv2jigguCSdP55/ulfiedBJdeCldeiVr0iuQ+R0pQBZxzfx066JzbCBSITEgiBzv6aPjkE9i+3SepHTuAk0+Gb7+F++6D997zd/pOnx7tUEUkjI6UoPZk8jWRsKpdG0aMgJ9/hssug/378WvSH3wQvvkG8ueHs8+Gfv1gj/7XFMkNjpSg6prZtlQe24Ha2RGgSLI2beCZZ2D8eOjbN8ULDRvC3Llw7bXwxBNQvz5MnhylKEUkXNJNUM65OOfcUak8ijvndIpPst2tt/quHE8/Da+9luKFYsVgyBD4+GPYudMvRW/XDn75JWqxikjWqLiZ5DiDB/vZ1E03wZQph7zYti0sWuTXpn/1lW/d0auXv4AlIjmKEpTkOPnz+04cp5wCF18MS5YcskGhQv4c4LJl0L27X6uuRRQiOY4SlORIRx3lV/bFx/tV538dttYUv/xvyBCfmMz8IooePXx1dBGJeUpQkmMdf7wvLPHHH3DhhbB7dxobNmnil//ddhsMG+bvn7r3XtinptAisUwJSnK0hg1h+HC/0vy66yDNCpHFivklgMuWwSWXwIABfiHF+vXZGa6IZIASlOR4nTrBQw/B22/DI48cYePjj/cbDh8OM2dCrVq+a++//2ZLrCISOiUoyRXuuQcuv9yfuRsxIoQdrrzSJ6iEBN+198QT4cUX0zlPKCLZTQlKcgUzeP11+N//fO756qsQdqpd2/fz+Oorn6BuucWXUPr00whHKyKhUIKSXCM+3i+aOOkkaN/eF5cIydlnw7Rp8MUXUKKEv5fqttvgn38iGa6IHIESlOQqpUv/l2dat4YVK0Lc0cy38vjhB7j9dnj+eShVyvf6eOop2Ls3kmGLSCqUoCTXqVTJJ6m9e6FVqwwu1CtUyJeqmD7dV6AAuPNOv1T9sDuCRSSSlKAkVzr1VN8hft06XxZp27YMHuB///OFZ7/7zjdFXLHCX7O66CJ/4KSkiMQtIv+JWIIys0Jm9oOZ/WxmC83swWB8mJmtMrO5wSMhGDcze87MlpvZPDOrn+JY3cxsWfDoFqmYJXc54wzffHf+fOjQAXbtyuSBOnaEBQv8qb9vvvGlK+rW9X3olahEIiaSM6jdwLnOubpAAtDazBoGr93hnEsIHnODsTZAteDRA3gZwMxKA/fjW803AO43s1IRjFtykVatfPGIqVP9MvT9+zN5oAoV/LWoNWvgnXf8+cNLLoEzz4SFC8MZsogEIpagnLcjeFogeKR1nz9Ae+CtYL/vgZJmVgFoBUxyzm1yzm0GJgGtIxW35D6XXeYvK40e7UvxZWnSU7CgP+DChTB0KCxdCvXqQZ8+8OefYYtZRCJ8DcrM4sxsLrABn2RmBi89EpzGG2xm8cFYReD3FLuvCcbSGhcJ2e23++7wQ4f6Nh1plkQKVVycr5S+ZMl/GbBKFV9vaeJEdfUVCYOIJijn3H7nXAJQCWhgZrWA/sApwOlAaSC5N6qldoh0xg9iZj3MbLaZzd64cWM4wpdc5oEHfEf4V1/1jQ+znKQAypaFN9/0ieryy+G99/x5xWOOgbvvhg0bwvBDRPKmbFnF55zbAnwFtHbOrQtO4+0G3sRfVwI/M6qcYrdKwNp0xg/9GUOcc4nOucRy5cqF/01IjmcGjz7qKxu9+CL07h2mJAVQrZovZfHXX74n/TnnwGOP+VnVXXepYaJIJkRyFV85MysZfF8YaA4sCa4rYWYGdAAWBLuMB64MVvM1BLY659YBXwAtzaxUsDiiZTAmkmFmfq1Dz56+uHnfvmFMUgCFC8MFF/gLXosW+T4gjz3mSyg98gj8+KNW/omEKJIzqArAVDObB8zCX4P6BHjXzOYD84GywIBg+8+AlcBy4DXgJgDn3Cbg4eAYs4CHgjGRTDHzl4xuusknq3vuCXOSSnbKKfDuu/D99z5B3XMPnHaar/v3zDOaVYkcgbmI/GZGV2Jiops9e3a0w5AYl5QEN9wAr70G99/vr1FF1Pr1MGGCPxX4zTe+HlOPHr7uX6VKEf7hIrHLzOY45xIPG1eCkrwsKQmuvdavcxgwwK9ryBY//ABPP+1v9nXOz6pq1PAzrIYNoXFj32RRJA9IK0Hlj0YwIrEiXz4/g9q3z5+By5/fX5eKuAYNfOOq1at9A8X58321io8/9gmrcGFo186XZT/hBKhaFcqXz4bARGKHEpTkeXFxfga1d69fhm7m68NmiypVfJfFZNu2+UaKY8f6BJay+2LVqr5G4Jln+kf16j5YkVxKp/hEAvv2+VuZRoyABx/0eSOq//7v3QuLF8Nvv/mKFd9+669dJd/nd+KJvjtj585+mbuSleRQugYlEoL9++Hqq+Gtt/ztSwMGxNi/+87BL7/A11/7TDp1qh+rWBHOPdcXtm3VyndvFMkhdA1KJATJp/vi4/1Nvbt2wcCBMZSkzPypverV/QrA336Dzz/3bes//dRfzzrqKKhf31dcT37UquXrCIrkIEpQIofIl8+XQypUCAYN8knq+ef9eMw57ji4/nr/2LsXpkzxfe9/+smv/ti5029Xpgx07QpXXeWL28ZMxhVJmxKUSCrM4NlnfZJ66in45x9/+1L+WP6NKVDA97lvHRT7378fli+HuXN9Y6xXX/WZtk4dn6guu0wrAyWm6RqUSDqc89eh7rsPLr7Y14LNsWfKNm3y162GDfP3YeXPD+ed5zs7nnCCb2tfufIRDyMSblokIZIFzzwDvXr59vGjR/vblHK0hQth+HCfsH777b/xM8/0pwI7dvSV2kWygRKUSBa9/rpfl3DWWf5+2uLFox1RmPzzjz8V+PHHfoq4eLGfXTVrBk2b+jfcsGGMXoST3EAJSiQMPvgArrjCL5L7/HMoXTraEYWZczBvnk9U48b5+6/AnwK8/no/u1LdQAmztBKU/iQSyYDOnf16g59/9pOLXNfl3cwvS3/iCd+EccMGeOcdn5T69vXXqBITfQuRlKcGRSJAMyiRTJgyxZfKq1ABvvjCF3XI9ZYu9SWYxo71LUTMfOmlNm2gZUu/fF2nASUTdIpPJMxmzoTzz/c3906Y4P99zjNWrvQzqzFj/DJ28IsqWrTwCyzOP1/VLCRkSlAiEbBkia8stHmzn1ice260I4qC9eth8mSYONFn6g0boFQpqFnTL3esXNkvuDjzTDjmGH+/lkgKSlAiEfLHH/7e2KVLfaWhTp2iHVEU7dvnz39+8IG/RrVzp/9gNm/+b5uyZf39V126+Art4HtfHX10jN8JLZGiBCUSQZs3+2tS33wDTz4JffqomtAB+/f70kuzZ/vZ1YoVfoXg1q0Hb2fmVwu2beszftmyfi1/tWq6tpXLKUGJRNiuXdCtG4wc6Vdkv/CCJgRp2r0bvvwStmzxS9u3b4e1a+HHH2HSJP96smOO8Y0bTzvNJ61TTvEP/QWQa6iauUiEFSoE77/vV/Q99phvljtypC8uLoeIj/er/1Lzzz8wa5ZPWn/95W84e+cdX0sw2UknwTnn+OPEx8NFF0GjRkpauYxmUCIR8PrrcMMNUKOG74KhEndZtGePX4yxcaNPXmPH+q/O+YS2e/d/bUXy5/ePAgXg2GP9ndVVqkT7HUg6dIpPJJtNmuRXXBctCp984qtPSATs2OErX7z5pr/GtW+fv+61b59/DtC4sb+eFRfnVxR26eJPHUpMUIISiYIFC/wtQX//7f8Nbdcu2hHlMb/95hPXhAk+ae3Y4WsNxsX5HllJSb6n1mWXwQUX+FlXcoJLSvKrDAsViva7yPWUoESiZN06n5jmzIGHHoK779alkqhassRfLNywwf+HmDPHtx9JTcGCcPrp/tRh2bL+2tcFF/jkJmGjBCUSRf/+6yuhv/OO7ys1bJi/9UdixNKlMGOGT1hxcf6RlOSLLk6fDqtW+QUbSUn+tTPO8F/37PGV3i+8EE491Se05FOJEjIlKJEoc863kL/zTl9kYexYf9uP5BBJSb6s04cf+qRVsKAf+/77g5fFFy4MCQl+OefOnbB3L5x9tp9GlynjF3WUKKHlnSkoQYnEiEmTfLUJM98vsHnzaEckWbJ9uy/1tG6dT1S//eZPG/76q58m79//X9uSlCpV8n+p1KgBJ5/sty1aFMqX96sPK1XKM2WhlKBEYsiKFf7e08WLYeBAuP12XZfK1Vat8gs1du/2Seivv2DRIv9YvNifAz5U/vx+in3yyVC9uq+oUaWKX9RRsqQ/lWjmF3UUKOBnbjn0fyIlKJEYs327rzwxZgxceSW88kouaCUvGZeU5GdfO3f603/r1/sCjytWwC+/+NnXsmW+VEl6zPzS+SZNoEEDX7C3aFGf1KpXj+numqokIRJjiheHUaNgwAC4/37/x/SYMWpYm+fkywcVK6a/TVKST1q//upPIW7b5v/CAb8gY98+v4R+5Up/fWzUqMOPUbGiX9xRo4ZPVhUr+q6b5cuH/S2Fi2ZQIjFg3Di4/HL/B+9HH/n7SkUybfNmPxvbts0nrSVLfJ3DmTP96caU/+4nL6GPj/enGrdv988bNPAzr/z5/fj8+f44Zcv6BSBxcb7gb/nyfuVPFugUn0iMW7gQOnTwfyQ/+6wvlZRDLylILEtK8oll+XLfw2vGDD/72rXLn2MuVszP1ubP9ws8khUp4hPW33/D77/7JFekiF9mP2VKlkJSghLJATZvhq5d/fX0iy+G117zlxJEst3OnT5RJSX5WVSVKv/d37V7t//rqWDBsPyotBKUmqyIxJBSpXxx2See8Kf9EhLg22+jHZXkSUWK+JWD1av/d0ovWXx82JJTeiKWoMyskJn9YGY/m9lCM3swGK9qZjPNbJmZjTCzgsF4fPB8efB6lRTH6h+MLzWzVpGKWSQW5MvnT+l/843/N+Hss/1CipRnW0TygkjOoHYD5zrn6gIJQGszawg8AQx2zlUDNgPXBNtfA2x2zp0EDA62w8xqAJ2BmkBr4CUzUx0RyfXOOMM3or30Urj3Xn9D7x9/RDsqkewTsQTlvB3B0wLBwwHnAslrIIcDHYLv2wfPCV5vZmYWjH/gnNvtnFsFLAcaRCpukVhSogS8+64vyP3DD77l0ccfRzsqkewR0WtQZhZnZnOBDcAkYAWwxTm3L9hkDZB8A0BF4HeA4PWtQJmU46nsk/Jn9TCz2WY2e+PGjRF4NyLRYQZXXeVXCVeu7Eu69ex55Ps2RXK6iCYo59x+51wCUAk/6zk1tc2Cr6ktqHXpjB/6s4Y45xKdc4nlypXLZMQisat6dV+XtGdPeO453+E8tRJvIrlFtqzic85tAb4CGgIlzSy5gkUlYG3w/RqgMkDweglgU8rxVPYRyVPi4+GZZ/xpvt9/911633zz4PsuRXKLSK7iK2dmJYPvCwPNgcXAVKBjsFk3YFzw/fjgOcHrXzp/k9Z4oHOwyq8qUA1Io7uYSN7Qtq1vVdSgAVx9tW8Iu3VrtKMSCa9IzqAqAFPNbB4wC5jknPsE6Av0NrPl+GtMbwTbvwGUCcZ7A/0AnHMLgZHAImACcLNzTgtuJc+rWNF3eRgwAEaOhHr10m4MK5ITqZKESC4wYwZ06QJr18Ijj0CfPv5+KpGcQJUkRHKxxo19s9f27aFvX2jdGv78M9pRiWSNEpRILlGqlO9G/uqrvuNC3bq+bJJITqUEJZKLmEGPHjB7Nhx9tF9M0b07bNkS7chEMk4JSiQXqlkTZs2Cu++Gt9/2LX8mTIh2VCIZowQlkkvFx/sVft9950smtWkD116r5eiScyhBieRyp58Oc+b4xRNvvgm1a8OkSdGOSuTIlKBE8oBCheDxx/1y9KJFoWVL37F3+/ZoRyaSNiUokTzkjDN80dk+fWDIED+b+vLLaEclkjolKJE8pnBheOop3xCxYEFo1gxuvhl27DjyviLZSQlKJI9Kvrm3Vy94+WWoUwe+/jraUYn8RwlKJA8rUgQGDfKJKV8+aNrUt/P4559oRyaiBCUiwJln+urot93me03VretPAYpEkxKUiAB+dd+zz8LUqZCUBGedBb17w86d0Y5M8iolKBE5SNOmMG8e3HQTDB7s23h89120o5K8SAlKRA5TrBi88AJMmQK7d8P//gd33AH//hvtyCQvUYISkTSdey7Mnw/XXQcDB/oW8zNnRjsqySuUoEQkXcWLwyuvwMSJfnVf48bQv7+fWYlEkhKUiISkRQs/m7r6al82qX59XzFdJFKUoEQkZCVKwGuvweef+6roDRv6pemqkC6RoAQlIhnWujUsXOhX+r34IlSvDu+9B85FOzLJTZSgRCRTSpSA55+HH36A446Dyy7zdf0WL452ZJJbKEGJSJacdpq/T+qVV+Cnn3wVirvu0g2+knVKUCKSZXFxcP31sHQpdO0Kjz0GNWrA+PHRjkxyMiUoEQmb8uVh2DBffLZYMWjfHtq1g9Wrox2Z5ERKUCISdmed5U/3PfWUb4hYowY88ogqUUjGKEGJSEQUKOA79y5eDG3awD33QLVq8MYbsG9ftKOTnEAJSkQiqnJlGD3an/arXBmuvdY3Rxw7VsvSJX1KUCKSLc46C2bMgI8+8u08LrwQmjSB6dOjHZnEKiUoEck2Zj4xLVgAQ4bAr7/6xHXBBb6MkkhKSlAiku3y5/cV0pctg0cf9bOounXhyiu14k/+owQlIlFTpIivjL5ypV9Q8eGHcPLJ0LMnbNwY7egk2pSgRCTqSpeGJ5/0M6pu3XyzxBNOgAcfhO3box2dRIsSlIjEjEqVfLX0hQuhVSt44AE48UR47jn1n8qLlKBEJOaccgqMGuW799aq5U/5nXIKvP027N8f7egku0QsQZlZZTObamaLzWyhmfUMxh8wsz/MbG7wOC/FPv3NbLmZLTWzVinGWwdjy82sX6RiFpHY0qABTJkCX3wBpUr5RRT16sEnn+geqrwgkjOofcD/OedOBRoCN5tZjeC1wc65hODxGUDwWmegJtAaeMnM4swsDngRaAPUALqkOI6I5HJm0LIlzJ4NH3zgyyVdcIFfnv7119GOTiIpYgnKObfOOfdj8P12YDFQMZ1d2gMfOOd2O+dWAcuBBsFjuXNupXNuD/BBsK2I5CH58kGnTrBoEbz8sl/517QpNG/u231I7pMt16DMrApQD5gZDN1iZvPMbKiZlQrGKgK/p9htTTCW1vihP6OHmc02s9kbtT5VJNcqUABuuAGWL4dBg/wNvo0bw3nn+VmW5B4RT1BmVgwYDdzunNsGvAycCCQA64CnkzdNZXeXzvjBA84Ncc4lOucSy5UrF47QRSSGFS4MvXr5mdTjj/sFFaefDh06wM8/Rzs6CYeIJigzK4BPTu865z4CcM6td87td84lAa/hT+GBnxlVTrF7JWBtOuMiIhQtCn37wqpV8NBD8NVXkJDge1FpRpWzRXIVnwFvAIudc4NSjFdIsdmFwILg+/FAZzOLN7OqQDXgB2AWUM3MqppZQfxCCvXpFJGDHHUU3HuvL5X04IO+fNLpp/tTf7pGlTNFcgbVBLgCOPeQJeVPmtl8M5sHnAP0AnDOLQRGAouACcDNwUxrH3AL8AV+ocXIYFsRkcOULAn33ecT1aOPwqxZ/hpVixYwbVq0o5OMMJcLbyZITEx0szW3FxHgn3/glVd8d9/16+Hss/1M69xz/RJ2iT4zm+OcSzx0XJUkRCRXK1oU/u///GKKZ57x9f6aN4czzoD33oM9e6IdoaRFCUpE8oQiRXzJpBUr/H1UW7fCZZfBSSfBiy/Crl3RjlAOpQQlInlKoUL+PqrFi+HTT30b+ltugapV4eGHYcOGaEcoyZSgRCRPypfPr/D75htf769uXb+44rjjoHt3mDs32hGKEpSI5GlmfsHEhAm+jNI118DIkb4obdOmMH48JCVFO8q8SQlKRCRw6qn+etQff8DAgf7m3/btoXp130Rxx45oR5i3KEGJiByiZEm/8m/FChgxAsqUgVtv9der+vaF338/4iEkDJSgRETSkD8/XHopfP89zJjhl6cPHOgXVHTsCF9+qb5UkaQEJSISgkaN4MMP/ayqVy+YOhWaNYMaNXxL+i1boh1h7qMEJSKSAVWq+KoUa9bA8OFQooS/v6piRejRA376KdoR5h5KUCIimVC4sG9B//33MGcOdO0K77wD9ev7VvWvv65FFVmlBCUikkX168Nrr/nVf889Bzt3wnXXwbHHwo03alaVWUpQIiJhUqqUX+03fz58+y1ceCEMG+YT2BlnwNChvnithEYJSkQkzMx8i4/hw2HtWl+kdvt2fxNwxYo+iS1YcMTD5HlKUCIiEVSqlF9EsXCh70fVtq0/HVi7tk9ir78O27ZFO8rYpAQlIpINzODMM/1Cij/+gKef9kvTr7sOKlTwCy6++kpllVJSghIRyWZlykDv3n5W9f33cMUVMG4cnHOOL6uU3Fwxr1OCEhGJEjO/eOKVV2DdOnj7bT+buvNOvwKwVSt46y1//SovUoISEYkBRYrA5Zf761SLFkH//r77b7ducPTR0Lmzr6yelzoAK0GJiMSYU0+FAQN8WaVvv4Wrr/Y9q9q39zOsG27wiSy3X69SghIRiVHJy9VfeMEvV//0U2jTxp8KPPtsOOEEuOceWLo02pFGhhKUiEgOUKCA7wD8zju+Lf277/qZ1mOPwSmn+PJKL7wAf/0V7UjDRwlKRCSHKVrU1/77/HNftPbpp2HvXn8DcIUK0K6dr7y+a1e0I80aJSgRkRysQgW/ZP2nn2DePN8KZM4c38fqmGN8hfXp03Pm9SolKBGRXKJ2bXjySfjtN5g0yc+k3nsPzjrLX6+66y5/71VOoQQlIpLLxMX57r9vveVv+H37bX+96sknoVYtSEjwNwPHeut6JSgRkVysaFF/f9Xnn//XDqRQIX8z8PHHQ9Omvjbg5s3RjvRwSlAiInnE0Uf7hRTffw/Ll8ODD8Kff/rrVMcc49uDfPgh/PtvtCP1lKBERPKgE0+Ee++FxYth9my4+WaYOdMvrihfHrp0gdGjffPFaFGCEhHJw8zgtNNg0CB/TWryZL+EffJk6NgRypXzSWvkyOxvYa8EJSIigF9c0awZvPqqL147ZYqvBThtGnTq5GdWF18M77+fPQVslaBEROQw+fPDuefCSy/5xRVffeU7An/3nZ9hlSvnawO+917kYlCCEhGRdMXF+dp/zz/vK1dMn+4L1s6Z4xNYpOSP3KFFRCS3yZcP/vc//xg0KLK1/yI2gzKzymY21cwWm9lCM+sZjJc2s0lmtiz4WioYNzN7zsyWm9k8M6uf4ljdgu2XmVm3SMUsIiKhy5fPX5eK2PEjd2j2Af/nnDsVaAjcbGY1gH7AFOdcNWBK8BygDVAtePQAXgaf0ID7gTOABsD9yUlNRERyr4glKOfcOufcj8H324HFQEWgPTA82Gw40CH4vj3wlvO+B0qaWQWgFTDJObfJObcZmAS0jlTcIiISG7JlkYSZVQHqATOBo51z68AnMSB5glgRSFkZak0wltb4oT+jh5nNNrPZGzduDPt7EBGR7BXxBGVmxYDRwO3OuW3pbZrKmEtn/OAB54Y45xKdc4nlypXLXLAiIhIzIpqgzKwAPjm965z7KBheH5y6I/i6IRhfA1ROsXslYG064yIikotFchWfAW8Ai51zg1K8NB5IXonXDRiXYvzKYDVfQ2BrcArwC6ClmZUKFke0DMZERCQXi+R9UE2AK4D5ZjY3GLsLeBwYaWbXAL8BlwSvfQacBywHdgLdAZxzm8zsYWBWsN1DzrlNEYxbRERigDl32OWcHC8xMdHNnj072mGIiEgIzGyOcy7x0HGVOhIRkZikBCUiIjFJCUpERGKSEpSIiMQkJSgREYlJSlAiIhKTcuUyczPbCPyayd3LAhHscBJ2OS1eyHkx57R4IefFrHgjL5ZjPt45d1iNulyZoLLCzGanth4/VuW0eCHnxZzT4oWcF7PijbycGLNO8YmISExSghIRkZikBHW4IdEOIINyWryQ82LOafFCzotZ8UZejotZ16BERCQmaQYlIiIxSQlKRERikhJUwMxam9lSM1tuZv2iHU9qzKyymU01s8VmttDMegbjpc1skpktC76WinasKZlZnJn9ZGafBM+rmtnMIN4RZlYw2jGmZGYlzWyUmS0JPutGsfwZm1mv4P+HBWb2vpkVirXP2MyGmtkGM1uQYizVzzRoWvpc8Ls4z8zqx0i8TwX/T8wzszFmVjLFa/2DeJeaWavsjjetmFO81sfMnJmVDZ5H/TMOhRIU/h9Q4EWgDVAD6GJmNaIbVar2Af/nnDsVaAjcHMTZD5jinKsGTAmex5KewOIUz58ABgfxbgauiUpUaXsWmOCcOwWoi489Jj9jM6sI3AYkOudqAXFAZ2LvMx4GtD5kLK3PtA1QLXj0AF7OphhTGsbh8U4Cajnn6gC/AP0Bgt/BzkDNYJ+Xgn9TstswDo8ZM6sMtMA3iE0WC5/xESlBeQ2A5c65lc65PcAHQPsox3QY59w659yPwffb8f9wVsTHOjzYbDjQISoBpsLMKgHnA68Hzw04FxgVbBJr8R4FnAW8AeCc2+Oc20IMf8b4ztiFzSw/UARYR4x9xs65acChnbDT+kzbA28573ugpJlVyJZAA6nF65yb6JzbFzz9HqgUfN8e+MA5t9s5twrfFbxBtgX7X3ypfcYAg4E7gZQr4qL+GYdCCcqrCPye4vmaYCxmmVkVoB4wEzjaObcOfBIDykcxtEM9g//lSAqelwG2pPhFj7XP+gRgI/BmcFrydTMrSox+xs65P4CB+L+O1wFbgTnE9mecLK3PNCf8Pl4NfB58H7Pxmlk74A/n3M+HvBSzMaekBOVZKmMxu/7ezIoBo4HbnXPboh1PWsysLbDBOTcn5XAqm8bSZ50fqA+87JyrB/xDjJzOS01w3aY9UBU4FiiKP31zqFj6jI8kpv8fMbO78afb300eSmWzqMdrZkWAu4H7Uns5lbGox3woJShvDVA5xfNKwNooxZIuMyuAT07vOuc+CobXJ0/Pg68bohXfIZoA7cxsNf606bn4GVXJ4HQUxN5nvQZY45ybGTwfhU9YsfoZNwdWOec2Ouf2Ah8BjYntzzhZWp9pzP4+mlk3oC1wmfvvJtJYjfdE/B8uPwe/g5WAH83sGGI35oMoQXmzgGrByqeC+Aue46Mc02GC6zdvAIudc4NSvDQe6BZ83w0Yl92xpcY51985V8k5VwX/mX7pnLsMmAp0DDaLmXgBnHN/Ar+bWfVgqBmwiBj9jPGn9hqaWZHg/4/keGP2M04hrc90PHBlsNKsIbA1+VRgNJlZa6Av0M45tzPFS+OBzmYWb2ZV8QsPfohGjCk55+Y758o756oEv4NrgPrB/+Mx+Rkfxjmnh/9D6Dz8ypwVwN3RjieNGP+Hn4bPA+YGj/Pw13WmAMuCr6WjHWsqsTcFPgm+PwH/C7wc+BCIj3Z8h8SaAMwOPuexQKlY/oyBB4ElwALgbSA+1j5j4H38NbK9+H8or0nrM8Wffnox+F2cj1+hGAvxLsdft0n+3XslxfZ3B/EuBdrEymd8yOurgbKx8hmH8lCpIxERiUk6xSciIjFJCUpERGKSEpSIiMQkJSgREYlJSlAiIhKTlKAkzzGz/WY218x+NrMfzaxxmI9/1yHPZ4TpuE3tv4rwTcMZt5lVMbOuKZ4nmtlz4Tq+SGYoQUle9K9zLsE5VxdfkfqxMB//oATlnAtrAgw0xVeMCFmKyhKpqQIcSFDOudnOudsyFZlImChBSV53FL4dRXKPnKfM91Wab2adjjBewcymBbOxBWZ2ppk9jq8sPtfM3g222xF8bWpmX9l/vabeDao/YGbnBWPfBH16Pkkr4KBQ8A1Ar+DnnGlm5cxstJnNCh5Ngm0fMLMhZjYReCuYKU0PZo4pZ4+PA2cGx+t1yGyttJmNNd836Hszq5Pi2EOD97TSzG4Lxoua2afBDHVB8uclklHp/UUlklsVNrO5QCGgAr5GIMBF+CoSdYGywCwzm4afqaQ23hX4wjn3iPn+P0Wcc9PN7BbnXEIaP7sevm/QWuBboImZzQZeBc5yzq0ys/fTC945t9rMXgF2OOcGApjZe/j+T9+Y2XHAF8CpwS6nAf9zzv1rvoBoC+fcLjOrhq8+kIgviNvHOdc2OF7TFD/yQeAn51wHMzsXeCv4PABOAc4BigNLzexlfE+itc6584NjlUjv/YikRQlK8qJ/kxOImTXCzyxq4UtJve+c248vZPo1cHo647OAoeYL+I51zs0N4Wf/4JxbE/zsufhTazuAlc73EgKfNHpk8D01B2oEEzKAo8ysePD9eOfcv8H3BYAXzCwB2A+cHMKx/wdcDOCc+9LMyqRIOp8653YDu81sA3A0vnTOQDN7Al/eanoG34sIoFN8ksc5577Dz4rKkXoLAtIad75B3FnAH8DbZnZlCD9yd4rv9+P/SEzr52ZEPqBRcG0twTlX0fmmluBbhiTrBazHzwYTgVBawafXmuGw9+Oc+wU/a5sPPGZmqbV7EDkiJSjJ08zsFHyb9L+BaUAnM4szs3L45PNDWuNmdjy+39Vr+Crz9YPD7g1mVaFaApwQXFsCCOWazXb8abVkE4FbUryvhDT2KwGsc84lAVfg33tqx0tpGnBZcNymwF8unT5kZnYssNM59w6+mWL9tLYVSY9O8UlelHwNCvzsoJtzbr+ZjQEaAT/jZwh3Ouf+TGe8G3CHme3Fn6ZLnkENAeaZ2Y/OtxdJV3Bt6CZggpn9RWitGj4GRplZe+BW4DbgRTObh/+9noZfSHGol4DRZnYJviVH8uxqHrDPzH4GhgE/pdjnAXyH4XnATv5rkZGW2sBTZpaEr6x9YwjvR+QwqmYuEgPMrJhzbkewqu9FYJlzbnC04xKJJp3iE4kN1wWzuoX403CvRjcckejTDEpERGKSZlAiIhKTlKBERCQmKUGJiEhMUoISEZGYpAQlIiIx6f8BYMkd3B1QrsAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {'n_estimators': 150,  # 迭代次数\n",
    "          'max_depth': 4,  # 基回归树最大深度\n",
    "          'min_samples_split': 5,  # 基回归树内部节点再划分所需最小样本数\n",
    "          'learning_rate': 0.01,  # 学习率\n",
    "          'loss': 'ls'}  # 损失函数\n",
    "\n",
    "def train_and_predict(params):\n",
    "    reg = GradientBoostingRegressor(**params)\n",
    "    reg.fit(X_train, y_train)\n",
    "    y_predict = reg.predict(X_test)\n",
    "    mse = mean_squared_error(y_test, y_predict)\n",
    "    print(\"测试集均方误差：{:.4f}\".format(mse))\n",
    "    \n",
    "    return reg\n",
    "\n",
    "################################################\n",
    "reg = train_and_predict(params)\n",
    "plot_staged_loss(params, reg)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 其他参数不变，增大树的最大深度max_depth到6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集均方误差：3914.5518\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAGoCAYAAAATsnHAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAABIY0lEQVR4nO3dd3xUVf7/8deHAKGEqsFFQCkiCkICRIosLEVBFBsrUlxF1rL2svburvr92V11V1dXWbugooidYoG1oFRFQZooTUA60kJyfn+cO0mAlAlk5k4y7+fjcR+TOXPn5jNXmXfuveeeY845REREEk2lsAsQEREpjAJKREQSkgJKREQSkgJKREQSkgJKREQSkgJKREQSkgJKJEGZ2SFmtsXMUsKuRSQMCiiR/WRmS8xsm5ltNrMNZva5mV1oZvv178s597NzLs05l1NWtYqUJwookbJxknOuFnAocA9wPfBMuCWJlG8KKJEy5Jzb6JwbBwwGhpvZUWaWamYPmNnPZrbKzP5tZtUBzGyumQ2IvN/MKpvZr2bWwcyampkzs8rBayOC9Teb2WIz+0uB9/U0s2VmdrWZrTazlWY2osDr1c3sQTP7ycw2mtn/CtTQJTjq22Bms82sZ3z2lkjxFFAiMeCc+wpYBnQH7gUOBzKBw4BGwG3Bqq8AQwu8tR/wq3NuRiGbXQ0MAGoDI4CHzaxDgdd/B9QJtn8u8C8zqxe89gDQETgGqA9cB+SaWSPgXeCuoP0aYIyZpe/rZxcpKwookdhZgf/SPx+4yjm3zjm3Gfg/YEiwzsvAyWZWI3g+LGjbi3PuXefcIud9CozHB2BENvB351y2c+49YAvQKrgW9mfgCufccudcjnPuc+fcDuBPwHvOufecc7nOuQnANOCEMtwPIvukctgFiFRgjfD/xmoA080s0m5ACoBzbqGZzQVOMrO3gZOB9oVtzMz6A7fjj8YqBdv9tsAqa51zuwo83wqkAQcC1YBFhWz2UGCQmZ1UoK0K8HH0H1MkNhRQIjFgZkfjA2osvsNEG+fc8iJWj5zmqwR875xbWMj2UoExwNnAW865bDMbiw+7kvwKbAdaALP3eG0p8IJz7vwotiMSVzrFJ1KGzKx20OlhFPCic2428B/89aIGwTqNzKxfgbeNAvoCF1HE6T2gKpAKrAF2BUdTfaOpyTmXC4wEHjKzg80sxcy6BqH3Iv7orV/QXi3ocNG41B9epIwpoETKxttmthl/RHIz8BC+IwP4I6iFwJdmtgmYCLSKvNE5txL4At+BYXRhGw+uXV0OvAqsx1+rGleK+q7Bnw78GliH77hRyTm3FDgFuAkffkuBa9F3gyQA04SFIiKSiPRXkoiIJCQFlIiIJCQFlIiIJCQFlIiIJKQKeR/UgQce6Jo2bRp2GSIiEoXp06f/6pzba3itChlQTZs2Zdq0aWGXISIiUTCznwpr1yk+ERFJSAooERFJSAooERFJSBXyGpSI7L/s7GyWLVvG9u3bwy5FKohq1arRuHFjqlSpEtX6CigRKdSyZcuoVasWTZs2pcBUISL7xDnH2rVrWbZsGc2aNYvqPTrFJyKF2r59OwcccIDCScqEmXHAAQeU6og8pgFlZnXN7HUzm2dmc4Mh/uub2QQzWxA81gvWNTN71MwWmtk3BaeyNrPhwfoLzGx4LGsWkXwKJylLpf3/KdZHUI8AHzjnjgAygLnADcAk51xLYFLwHKA/0DJYLgCeADCz+vhZRDsDnYDbI6EmIiIVV8wCysxqAz2AZwCcczudcxvwc888F6z2HHBq8PMpwPPO+xKoa2YNgX7ABOfcOufcemACcHys6haRxLB27VoyMzPJzMzkd7/7HY0aNcp7vnPnzmLfO23aNC6//PISf8cxxxxTVuXuZeTIkbRt25Z27dpx1FFH8dZbbxW7/tixY/n+++8Lfe2OO+7I+/wtW7Zk4MCBRa4bjfPOO2+/3h8vsewk0Rw/Adp/zSwDmA5cARwUTNCGc25lZJZR/PTYSwu8f1nQVlT7bszsAvyRF4ccckjZfhIRibsDDjiAWbNmAf4LOi0tjWuuuSbv9V27dlG5cuFfYVlZWWRlZZX4Oz7//PMyqXVPy5Yt4+6772bGjBnUqVOHLVu2sGbNmmLfM3bsWAYMGEDr1q0Lff2qq67K+/yjR4+md+/efPvtt6Sn7zVCUImefvrpUr8nDLE8xVcZ6AA84ZxrD/xG/um8whR2ctIV0757g3NPOeeynHNZ+/IfTEQS3znnnMNf//pXevXqxfXXX89XX33FMcccQ/v27TnmmGP44YcfAPjkk08YMGAA4MPtz3/+Mz179qR58+Y8+uijedtLS0vL+/m+++6jbdu2ZGRkcMMN/qtq4cKFHHvssWRkZNChQwcWLVoEwP3338/RRx9Nu3btuP322/eqc/Xq1dSqVStv+2lpaXk91xYtWsTxxx9Px44d6d69O/PmzePzzz9n3LhxXHvttWRmZub9nqIMHjyYvn378vLLLwMwffp0/vCHP9CxY0f69evHypUrmTt3Lp06dcp7z5IlS2jXrh0APXv2zBsO7qKLLiIrK4s2bdrs9lmaNm3K7bffTocOHWjbti3z5s0DYMuWLYwYMSLv6HDMmDEAjB8/nq5du9KhQwcGDRrEli1biv0M0YjlEdQyYJlzbmrw/HV8QK0ys4bB0VNDYHWB9ZsUeH9jYEXQ3nOP9k9iWLeI7OHKKyE4mCkzmZnwj3+U/n3z589n4sSJpKSksGnTJiZPnkzlypWZOHEiN910U94XZkHz5s3j448/ZvPmzbRq1YqLLrpot3tx3n//fcaOHcvUqVOpUaMG69atA+DMM8/khhtu4LTTTmP79u3k5uYyfvx4FixYwFdffYVzjpNPPpnJkyfTo0ePvO1lZGRw0EEH0axZM/r06cPAgQM56aSTALjgggv497//TcuWLZk6dSoXX3wxH330ESeffDIDBgzg9NNPj2o/dOjQgXnz5pGdnc1ll13GW2+9RXp6OqNHj+bmm29m5MiR7Ny5k8WLF9O8eXNGjx7NGWecsdd27r77burXr09OTg59+vThm2++yQuyAw88kBkzZvD444/zwAMP8PTTT3PnnXdSp04dvv32WwDWr1/Pr7/+yl133cXEiROpWbMm9957Lw899BC33XZblP9VCxezgHLO/WJmS82slXPuB6AP8H2wDAfuCR4jJ2bHAZea2Sh8h4iNQYh9CPxfgY4RfYEbY1W3iCS2QYMGkZKSAsDGjRsZPnw4CxYswMzIzs4u9D0nnngiqamppKam0qBBA1atWkXjxo3zXp84cSIjRoygRo0aANSvX5/NmzezfPlyTjvtNMDfZAr+SGH8+PG0b98e8EcUCxYs2C2gUlJS+OCDD/j666+ZNGkSV111FdOnT+eaa67h888/Z9CgQXnr7tixY5/2g3P+RNIPP/zAnDlzOO644wDIycmhYcOGAJxxxhm8+uqr3HDDDYwePZrRo0fvtZ1XX32Vp556il27drFy5Uq+//77vIAaOHAgAB07duSNN97I21ejRo3Ke3+9evV45513+P777+nWrRsAO3fupGvXrvv0uQqK9Y26lwEvmVlVYDEwAn9a8VUzOxf4GYj8l3oPOAFYCGwN1sU5t87M7gS+Dtb7u3NuXYzrFpEC9uVIJ1Zq1qyZ9/Ott95Kr169ePPNN1myZAk9e/Ys9D2pqal5P6ekpLBr167dXnfO7dUFOhIAe3LOceONN/KXv/yl2DrNjE6dOtGpUyeOO+44RowYwV//+lfq1q2bd21tf8ycOZOsrCycc7Rp04Yvvvhir3UGDx7MoEGDGDhwIGZGy5Ytd3v9xx9/5IEHHuDrr7+mXr16nHPOObvdpxTZbwX3WVH76rjjjuOVV17Z789VUEy7mTvnZgXXhdo55051zq13zq11zvVxzrUMHtcF6zrn3CXOuRbOubbOuWkFtjPSOXdYsPw3ljUD9O0LN+oYTSThbdy4kUaNfJ+pZ599dp+307dvX0aOHMnWrVsBWLduHbVr16Zx48aMHTsW8Ec6W7dupV+/fowcOTLvGsvy5ctZvXr1bttbsWIFM2bMyHs+a9YsDj30UGrXrk2zZs147bXXAP/FPnv2bABq1arF5s2bo6p3zJgxjB8/nqFDh9KqVSvWrFmTF1DZ2dl89913ALRo0YKUlBTuvPNOBg8evNd2Nm3aRM2aNalTpw6rVq3i/fffj2pf/fOf/8x7vn79erp06cJnn33GwoULAdi6dSvz58+P6rMURyNJFGLdOpg5M+wqRKQk1113HTfeeCPdunUjJydnn7dz/PHHc/LJJ5OVlUVmZiYPPPAAAC+88AKPPvoo7dq145hjjuGXX36hb9++DBs2jK5du9K2bVtOP/30vYIlOzuba665hiOOOILMzExGjx7NI488AsBLL73EM888Q0ZGBm3atMnrfj5kyBDuv/9+2rdvX2gniYcffjivm/mLL77IRx99RHp6OlWrVuX111/n+uuvJyMjg8zMzN16Jw4ePJgXX3yx0OtPGRkZtG/fnjZt2vDnP/857xRdcW655RbWr1/PUUcdRUZGBh9//DHp6ek8++yzDB06lHbt2tGlS5e8ThX7w4o6jC3PsrKy3P5MWDhkCEybBsEfAyJJae7cuRx55JFhlyEVTGH/X5nZdOfcXvcF6AiqEC1awE8/wR6nqUVEJI4UUIU47DAfTj//HHYlIiLJSwFViBYt/KNO8YmIhEcBVYhIQJVwM7eIiMSQAqoQDRtC9eo6ghIRCZMCqhCVKkHz5jqCEhEJkwKqCC1aKKBEwrQ/022AHzC2qNHKV61axYABA8jIyKB169accMIJxW5rw4YNPP7440W+npKSQmZmJm3atCEjI4OHHnqI3NzcEmssTLRThSSDWA91VG4ddhhMmADOgSYVFYm/kqbbKMknn3xCWlpaoXM+3XbbbRx33HFcccUVAHzzzTfFbisSUBdffHGhr1evXj2v1tWrVzNs2DA2btzI3/72t6jrjYh2qpBkoCOoIrRoAdu2wcqVYVciIhGFTSsB8Oijj9K6dWvatWvHkCFDWLJkCf/+97/zRl+YMmXKbttZuXLlboPFRgZHhcKn0rjhhhtYtGgRmZmZXHvttcXW2KBBA5566in++c9/4pwjJyeHa6+9Nm+bTz75JOBHeHjvvffy3nfOOecwZsyY3aYKKWo6kWeffZaBAwdy/PHH07JlS6677rq87XzwwQd06NCBjIwM+vTpA8Bvv/3Gn//8Z44++mjat29f4uSJiUJHUEUo2NX84IPDrUUkdAkw34ZzrshpJe655x5+/PFHUlNT2bBhA3Xr1uXCCy8s8qjrkksuYfDgwfzzn//k2GOPZcSIERx88MFFTqVxzz33MGfOnKgHeW3evDm5ubmsXr2at956izp16vD111+zY8cOunXrRt++fRkyZAijR4/mhBNOYOfOnUyaNIknnniCqVOn5m3niCOOKHI6kVmzZjFz5kxSU1Np1aoVl112GdWqVeP8889n8uTJNGvWLG/akLvvvpvevXszcuRINmzYQKdOnTj22GN3G3g3ESmginDYYf5x0SIoMIq+iIRkx44dRU4r0a5dO84880xOPfVUTj311BK31a9fPxYvXswHH3zA+++/T/v27ZkzZ06RU2nsyyzdkWHkxo8fzzfffMPrr78O+AFuFyxYQP/+/bn88svZsWMHH3zwAT169KB69eq7baO46UT69OlDnTp1AGjdujU//fQT69evp0ePHnmTI9avXz+vhnHjxuWNMbh9+3Z+/vnnhB/KSgFVhEMOgZQUdZQQARJivo3ippV49913mTx5MuPGjePOO+/MG827OPXr12fYsGEMGzaMAQMGMHny5CKn0liyZEmpal28eDEpKSk0aNAA5xyPPfYY/fr122u9nj178uGHHzJ69GiGDh261+vFTSdS2BQihU2FAX7fjRkzhlatWpXqc4RN16CKUKUKNG2qe6FEEkVqamqh00rk5uaydOlSevXqxX333ceGDRvYsmVLsdNXfPTRR3lTa2zevJlFixZxyCGHFDmVRmmmwlizZg0XXnghl156KWZGv379eOKJJ/KOfubPn89vv/0G+BHM//vf/zJlypRCA6y004l07dqVTz/9lB9//BEg7xRfv379eOyxx/KO6maWk+kadARVDHU1F0kclSpV4vXXX+fyyy9n48aN7Nq1iyuvvJLDDz+cP/3pT2zcuBHnHFdddRV169blpJNO4vTTT+ett97iscceo3v37nnbmj59OpdeeimVK1cmNzeX8847j6OPPhrwo21HZoNNS0vjxRdfpEWLFnTr1o2jjjqK/v37c//99+9W27Zt28jMzCQ7O5vKlStz1lln8de//hWA8847jyVLltChQwecc6Snp+fNMdW3b1/OPvtsTj75ZKpWrbrXZ77uuusYPnw4Dz30EL179y5xH6Wnp/PUU08xcOBAcnNzadCgARMmTODWW2/lyiuvpF27djjnaNq0Ke+8884+/XeIJ023UYyLL4ZXXoH168ugKJFyRtNtSCxouo0ycthhsGGDn8BQRETiSwFVDA0aKyISHgVUMSJdzefPD7cOkbBUxEsAEp7S/v+kgCrGYYf5gWMVUJKMqlWrxtq1axVSUiacc6xdu5Zq1apF/R714itGaqrvah6MLiKSVBo3bsyyZctYs2ZN2KVIBVGtWrXdhpgqiQKqBK1aKaAkOVWpUiVvRAKRMOgUXwlatfKn+PZx5HwREdlHCqgSHH44bN0Ky5eHXYmISHJRQJUgMnSVTvOJiMSXAqoEkYBSTz4RkfhSQJXg4IMhLU1HUCIi8aaAKoGZvw6lgBIRiS8FVBQUUCIi8aeAikKrVvDTT7BtW9iViIgkDwXUnpyDv/0NXnwxr6lVK9+syQtFROJHAbUnMxgzZq+AAvXkExGJJwVUYTp3hq++8odN+GtQoOtQIiLxpIAqTOfOfhrdBQsA38384IMVUCIi8aSAKkznzv5x6tS8Jg0aKyISXwqowrRu7Q+bCgkoTY0jIhIfCqjCpKRAVtZeAbVhA2hqHBGR+FBAFaVzZ5g9G7ZvBzRorIhIvCmgitK5M2Rnw8yZgLqai4jEmwKqKHt0lDj0UKhaVUdQIiLxooAqysEHQ+PGeQGVkgKHHaaAEhGJFwVUcTp3VldzEZGQKKCK07kz/PhjXte9Vq1g0SJ/aUpERGJLAVWcLl38Y3AU1aoV7NrlM0tERGJLAVWcjh2hcmX44gsgvyffvHkh1iQikiQUUMWpUQMyMvICqnVr3/zddyHWJCKSJBRQJenWDb78ErZto04d37FPASUiEnsKqJKceKKfSnfCBADatFFAiYjEQ0wDysyWmNm3ZjbLzKYFbfXNbIKZLQge6wXtZmaPmtlCM/vGzDoU2M7wYP0FZjY8ljXvpWdPqFsX3nwTgKOOgrlzIScnrlWIiCSdeBxB9XLOZTrnsoLnNwCTnHMtgUnBc4D+QMtguQB4AnygAbcDnYFOwO2RUIuLqlXhpJNg3DjIzqZNG9ixw3c3FxGR2AnjFN8pwHPBz88BpxZof955XwJ1zawh0A+Y4Jxb55xbD0wAjo9rxaedBuvWwWef0aaNb9JpPhGR2Ip1QDlgvJlNN7MLgraDnHMrAYLHBkF7I2BpgfcuC9qKat+NmV1gZtPMbNqasp4To3dvMINPP1VPPhGROIl1QHVzznXAn767xMx6FLOuFdLmimnfvcG5p5xzWc65rPT09H2rtih16vju5pMnk5YGTZvCnDll+ytERGR3MQ0o59yK4HE18Cb+GtKq4NQdwePqYPVlQJMCb28MrCimPb569IDPP4fNm9WTT0QkDmIWUGZW08xqRX4G+gJzgHFApCfecOCt4OdxwNlBb74uwMbgFOCHQF8zqxd0jugbtMXX6af7yQvfeoujjvKDxmpMPhGR2Kkcw20fBLxpZpHf87Jz7gMz+xp41czOBX4GBgXrvwecACwEtgIjAJxz68zsTuDrYL2/O+fWxbDuwnXrBoccAi+9RJthfyI7GxYuhCOPjHslIiJJIWYB5ZxbDGQU0r4W6FNIuwMuKWJbI4GRZV1jqVSqBMOGwf33k3H1aqABc+YooEREYkUjSZTG4MGQk8MRi9/DTNehRERiSQFVGu3aQXo6VadMokULBZSISCwpoEqjUiXo0wcmTqRNa6eu5iIiMaSAKq0+feCXX+h50FwWLPDDHomISNlTQJVWH9+/o/uOieTkwPz5IdcjIlJBKaBKq1kzOOIIjpz+IuB0HUpEJEYUUPviyiup8d3XdKv0pa5DiYjEiAJqXwweDJUqMaze+zqCEhGJEQXUvqhbFzp14lg3XgElIhIjCqh9dcopHL5uKrUWzmTbtrCLERGpeBRQ++rCC8muXouL3L+YNy/sYkREKh4F1L6qW5dtPfrRjw/5ZvZe01OJiMh+UkDth7TT+tKEZaye9G3YpYiIVDgKqP1Q6bRT2FapBu0n3Bt2KSIiFY4Can80aMDkoy6m16pRuCU/hV2NiEiFooDaT6tOvxSAbVfdBLm5IVcjIlJxKKD2U/Neh/J3bqPG2Jdh1KiwyxERqTAUUPupXTu4k1tZ3aAN3H23jqJERMqIAmo/1a4NzZpX4pVmN8P338PYsWGXJCJSISigykBGBvx73RnQsiXcdRc43RclIrK/FFBlICMDfliYwo6/3ggzZ8Kzz4ZdkohIuaeAKgOZmf6gaWbbs6FXL7j0Un+6T0RE9pkCqgxkZPjH2XNS4MUXITUVbrkl3KJERMo5BVQZOPRQqFMHZs8GDj4YzjsPxo2DFSvCLk1EpNxSQJUBM9/dfPbsoOEvf/Hn/B58MNS6RETKMwVUGcnM9AGVmwu0aAFDhsB//gPbt4ddmohIuaSAKiMZGfDbb7B4cdBw1lmweTOMHx9qXSIi5ZUCqozkdZSInObr0wcOOACeey60mkREyjMFVBlp0wZSUmDWrKChShU4/3w/ssQnn4RXmIhIOaWAKiPVq8ORR8KMGQUar7oKDj8cTjkF1q0LrTYRkfJIAVWGOnSA6dMLjHTUoAG8+qq/FqUefSIipaKAKkMdO8KqVXvc/tS2LZxxBjzyCKxZE1ptIiLljQKqDHXs6B+nT9/jhTvugG3b4L774l2SiEi5pYAqQ5mZUKlSIQF1xBFw5pnwz3/C8uVhlCYiUu4ooMpQzZo+i3brKBHxt79BTo5/FBGREimgyliko8RemjWDCy+EkSNh3ry41yUiUt4ooMpYx46wcqVf9nLLLb4/+k03xb0uEZHyRgFVxorsKAG+2/n118Obb8Jnn8W1LhGR8kYBVcbat/ejmxcaUOBv3m3YEK67TlPDi4gUQwFVxtLS/IgSX31VxAo1a/pu559/DpMnx7M0EZFyRQEVA506wdSpxRwgnXkm1KgBo0bFtS4RkfJEARUDnTvD2rUFpt7YU82acOqp8PLLsGFDHCsTESk/FFAx0Lmzf5w6tZiVrr0WNm2CRx+NS00iIuWNAioG2rb1vcmLDajMTDj5ZHj4YR1FiYgUQgEVA5Ur++7mxQYU+M4SGzfC3XfHoywRkXJFARUjnTvDzJmwY0cxK7Vv76eGf/xxHUWJiOxBARUjnTvDzp3wzTclrHj55bB1K/zrX3GpS0SkvFBAxUhUHSXAnws87TR/uq/ElUVEkkfMA8rMUsxsppm9EzxvZmZTzWyBmY02s6pBe2rwfGHwetMC27gxaP/BzPrFuuay0KQJ/O53UWbOM89A48ZwzjmQmxvr0kREyoV4HEFdAcwt8Pxe4GHnXEtgPXBu0H4usN45dxjwcLAeZtYaGAK0AY4HHjezlDjUvV/M/FFUVAFVrx7ceacf5fz992Nem4hIeRDTgDKzxsCJwNPBcwN6A68HqzwHnBr8fErwnOD1PsH6pwCjnHM7nHM/AguBTrGsu6x07gwLFsC6dVGsPGgQNG/up4fXQLIiIjE/gvoHcB0QOW91ALDBObcreL4MaBT83AhYChC8vjFYP6+9kPfkMbMLzGyamU1bs2ZNGX+MfRO5DlXkuHwFpab6YGrUCIYO9T0sRESSWMwCyswGAKudcwXH9bZCVnUlvFbce/IbnHvKOZflnMtKT08vdb2xkJXlT/VF3ffhd7+DRx6BpUv9dSkRkSQWyyOobsDJZrYEGIU/tfcPoK6ZVQ7WaQysCH5eBjQBCF6vA6wr2F7IexJa7drQunUpO+cdfzz06gXXXANz55a8vohIBRWzgHLO3eica+yca4rv5PCRc+5M4GPg9GC14cBbwc/jgucEr3/knHNB+5Cgl18zoCUQzUmzhNC5sz/FF/XUT2bw4ot+tPPTToPVq2Nan4hIoqpc8ipl7npglJndBcwEIueyngFeMLOF+COnIQDOue/M7FXge2AXcIlzLif+Ze+bzp1h5EhYtAgOOyzKNx18MLzxBvTtC1dcAa+8EtMaRSQJ7NwJW7b44W127oTt2/2ybVv+z3su27bB5s3+PdnZULWqH57NzC/O+e+rG26IScnmKuCsrllZWW7atGlhlwHA7Nl+XNiXXoJhw0r55ltvhbvugjlzoE2bWJQnIvGUne1P3a9alR8YW7dCpUp+EM+cHD/rafXq/vWtW/2yfbt/vmOHXwoGyNatfjtr1vi21NT8bRdcsrP3ve7Klf2yYwfUreuDyTkfUp06wYcf7tduMbPpzrmsvX7tfm1VStSmjZ/+6Ysv9iGgrrgC7r/fD4P0+OMxqU+kzGzaBDNm+HElc3P9RdicnPwvt8iSmur/Es/J2XvZtSv/5zp1/OOWLf6v+MiXceXK/h9VZKlRwz/WquXfs307VKvmv/Q3b/Zf+DVr+i/TaDjn64/UUr363u91Dn77zZ+C37ABGjTwk8BlZ0P9+n79LVtg1iy/T+bP9/c5Ll9ewgCdUapc2dcVWWrVggMOgPR0v/1ateDQQ/1njyy1avl9Va2a3//Vq/ufC1sKvpaW5n8f+H1SOX6xoYCKscqVoWtXmDJlH9584IEwfDg88QQceywMHFjm9YkUa/16mDbNf/nWquW/rCJf1l9+CZMn+y/gtWsT+9aISpXyv6R37fLhEvks1av7YKlUyQfOtm27vzclxYdOnTo+mDZt8qEU7RFJ9erQrJk/0mjUyA9v1qSJD+pIwObm+u1VqZJ/VJWa6l+LhEUk2KtW9TWFIY7hBAqouOje3Q+1t2GDPzoulUcegenT4eKL4ZhjfFd0kdLIzoYff/Tnm3/4If8v/cgRS5Mm/ovxu+98GG3enH9qqaTQadMGevf226hVy3/5Nmjgv3C3bvVfpJHfs2uX/72RayApKflL5cq7P69Uyf+DqVIl/wigZk3/ZR0JmMiydat/3LjRh0f16v4oKjvb/4PbvDl/2bTJf8HXqOGfQ36dzsFBB/nfEznaixyFrV2bf+2lVi0/+ku9ev6z1qnjT9kdcIAPkcid+TVr+mDq0MFvR0pNARUHPXr4//c/+wxOPLGUb65Wzd8Tdcwxfpr4KVP8P1qRgrZs8X/I/PgjLFmy++Py5buP8ZiW5r9IK1Xyy6pVvj093f81Va9e/mmzevX8DX0NG/rA2LYt//pDixb+C1gkRhRQcdC5s8+UyZP3IaAAMjLgv/+FwYP9kdSTT+ovsmSXk+MnHHvmGX99Y/p0/xc++L/yGzWCpk2hZ0//2Ly5n+q5dWt/hFHQjh0+cFJTo79OIxIHCqg4qF4djj56H69DRZxxhp9c6u67/SkKzR9V8TkHK1b4C+1Ll/peWqmpvm38eN8brGZNHzynnur/Hzn88PzrG9EqzboicaSAipPu3eHBB/3p7ho19nEjd97pT7E89BD07w8DBpRpjRKC7GxYtmzvU3Pz5vkA+u23vd9TsyYccQQ89hicfrquS0qFpfug4uS99/zpvY8+8iMZ7bOdO/3h2OrV/qJ2/fplVqPEwPr1MGkS/PKLD6LsbH9NaPNmWLjQ38GdU+C+80qV/BFQixZw1FH+7u727f3zAw/0f+HUrq1TcVKh6D6okB1zjP9OmTx5PwOqalV49lnfZfWyy/wdwJI4tm3zo4BMmeK7X8+YkR9AVar43mJNmviOCu3a5U+z0qyZv1bUuHHxnWDq1InLxxBJBAqoOKlb1/d12K/rUBHt28Mtt/i+6wMG+Ok5JDyrV/tTcmPHwvPP+y7Jder4/0433ugHAG7a1A8JoyMfkagpoOKoe3ff6SpyP95+uekmmDDBTxP/008+pA49tCzKlJJs2wb/+5/vqDB+vO+8Av7otn9/uPJK+MMfFEYi+0l9leOoRw9/CWHGjDLYWJUq8PbbfkDZG2/0f6HrdF9sOAfffw8PPOD3d/36/vHRR/3Nmf/3f/D66/5IauxY37Vb4SSy33QEFUfdu/vHyZPzZ9vdL/Xqwbhx8P77cNtt8Kc/+WGR3n1X1yr216+/+s4NX37p/xBYtMi3t24NF17oA6pHD9+jTkRiQr344qxVK7+MG1fGG960Cc4/H159FU44AZ57zvf6kugsXuz33Sef+AuF2dl+SU2FPn3gpJN8N8wmTUrclIiUjnrxJYgePfzZoJycMh7vsXZtGD3ad03+29/8F+obb/ghapLNihV+WJ4DDsgfwTk3149Ft2GD79791Ve+2/eqVX5ZEUzS3Ly5v+H1oIPglFN8TzsdJYmEQgEVZ717w9NP+8EBOnaMwS+49VY/gOewYXDkkXDRRTBihB9hYF9s3uzv5dm+3XcIGDvWD9a5di20bOlvGP3hB3+DaU6Ov0/ryCP9UDuHHOK/5Pf1d4P/3dWr+/uDqlbd/TXn/Ovz58PHH/tzpwsW5J+OA9+du00bf/NrZMw58NeRmjf3AZ6Z6Q9rzzzTd/MWkYSgU3xx9ssv/jvxvvvg2mtj+Ivmz4frrvPXT3JzfW+/hx7y162i8eGH8NZb8PLL+WO8gT9CS0nxXaYXL/ZHIwcdlD/GW0qK73K9dGn+KAjVq/vpQq64wie0Gfz8sz8NGZk+4Isv/DY7dPCDlv78M7zwgh9hF/ygufXr+95xKSk+cGbPzh+RGvyQP4cfDl26+G2tWeNvZv7xR380dcIJftSF5s39ja/qyCCSEIo6xaeACkGbNv7g4v334/DLVqzwU3Y8+KD/4r/3Xj869aJF/j6dGTP8z+vW+S/uzEwfbBMn+tOGv/89HHecvxbTqpW/y7jgF3t2tp+WYM8v+5wcn8Yvv+yDbNw4X0ujRv49v/66+wjbhxzie8Ft357fdvjhfg6syPQK69f7oThyc/2NZZ06+c/SrJm/E7pBg1juSRGJEQVUArnsMhg50n/f7nnWKmZmzPCn+iL37BSnQQPf4eLWW8tuINHt2/0R0+TJPtDq1YOrr87fAQcd5O8vWrrUn4o76CA/zI9GbRep8BRQCeTNN/2BwZQp/gAlbrKzfbfpb77x11pGjYJ+/Xz/99Wr/Wm1L7+Em29WD0ARiRsFVAJZt85//99xh799SUQkmRUVUDp/EoL69f3ln48+CrsSEZHEpYAKSe/evuPa1q1hVyIikpgUUCHp3dvfMvT552FXIiKSmBRQIene3Xdmmzgx7EpERBKTAiokaWnQtaufMUNERPamgApRv37+9qTVq8OuREQk8SigQtS3r3/UaT4Rkb0poELUoYMfIm78+LArERFJPFEHlJlVN7NWsSwm2aSk+DFUx4/3A3OLiEi+qALKzE4CZgEfBM8zzaysp9xLSv36wcqVMGdO2JWIiCSWaI+g7gA6ARsAnHOzgKaxKCjZHHecf/zww3DrEBFJNNEG1C7n3MaSV5PSatzYT7+h61AiIruLNqDmmNkwIMXMWprZY4DGQCgjffv6WSg07JGISL5oA+oyoA2wA3gZ2AhcGaOakk6/frBjh59+Q0REvKgCyjm31Tl3s3Pu6GC5xTm3veR3SjS6d/fzAuo6lIhIvmh78U0ws7oFntczM32dlpEaNXxIffBB2JWIiCSOaE/xHeic2xB54pxbDzSISUVJ6sQTYe5cWLw47EpERBJDtAGVa2aHRJ6Y2aGAbi0tQyed5B/feSfcOkREEkW0AXUz8D8ze8HMXgAmAzfGrqzk06IFHHkkvP122JWIiCSGaDtJfAB0AEYDrwIdnXO6BlXGBgyATz+FTZvCrkREJHylGSw2FViH72Le2sx6xKak5HXSSZCdrd58IiIAlaNZyczuBQYD3wG5QbPDn+qTMtK1K9Sv70/zDRoUdjUiIuGKKqCAU4FWzrkdMawl6VWuDCecAO+9Bzk5frRzEZFkFe0pvsVAlVgWIt6AAbB2LXz5ZdiViIiEK9ojqK3ALDObhB/uCADn3OUxqSqJHX88VKkCY8dCt25hVyMiEp5oA2pcsEiM1anjJzF87TW47z4wC7siEZFwRBVQzrnnYl2I5DvjDBgxAr7+Gjp1CrsaEZFwRDsWX0sze93MvjezxZGlhPdUM7OvzGy2mX1nZn8L2puZ2VQzW2Bmo82satCeGjxfGLzetMC2bgzafzCzfvvxecuFU07xp/leey3sSkREwhNtJ4n/Ak8Au4BewPPACyW8ZwfQ2zmXAWQCx5tZF+Be4GHnXEtgPXBusP65wHrn3GHAw8F6mFlrYAh+uo/jgcfNrEL3b6tXz88R9eqr4DSglIgkqWgDqrpzbhJgzrmfnHN3AL2Le4PztgRPqwSLC973etD+HL4LO8ApwXOC1/uYmQXto5xzO5xzPwIL8dPPV2iDBsHPP8NXX4VdiYhIOKINqO1mVglYYGaXmtlpRDGauZmlmNksYDUwAVgEbHDO7QpWWQY0Cn5uBCwFCF7fCBxQsL2Q91RYkdN8r74adiUiIuGINqCuBGoAlwMdgbOA4SW9yTmX45zLBBrjj3qOLGy14LGw/mqumPbdmNkFZjbNzKatWbOmpNISXt26fqbd117TaT4RSU7RDhb7tXNui3NumXNuhHNuoHMu6ltJg7mkPgG6AHXNLNJ7sDGwIvh5GdAEIHi9Dn7sv7z2Qt5T8Hc85ZzLcs5lpaenR1taQjvjDFi6FKZODbsSEZH4KzagzOwfwePbZjZuz6WE96ZHZuE1s+rAscBc4GPg9GC14cBbwc/jyD8qOx34yDnngvYhQS+/ZkBLICmuzJx8MlStqtN8IpKcSroPKtJT74F92HZD4Lmgx10l4FXn3Dtm9j0wyszuAmYCzwTrPwO8YGYL8UdOQwCcc9+Z2avA9/hehJc453L2oZ5yp06d/NN8DzwAlUoz9ryISDlnLooLHEGniPfKy2CxWVlZbtq0aWGXUSZefBHOOgs+/9yPdi4iUtGY2XTnXNae7dH+TX4yMD+YUffEAteQJMZOPhlSU3WaT0SST7SdJEYAhwGvAcOARWb2dCwLE692bT+A7GuvQW5uyeuLiFQUUV/VcM5lA+8Do4Dp+BtoJQ4GDYLly+GLL8KuREQkfqIdi+94M3sWP4rD6cDT+E4QEgcnneRP82lsPhFJJtEeQZ0DjAUOd84Nd869V2A0CImx2rWhf3+d5hOR5BLtNagh+C7h3cHf12RmtWJZmOzujDNgxQrfm09EJBlEe4rvfPwArk8GTY3xR1QSJwMGqDefiCSXaE/xXQJ0AzYBOOcWEMVgsVJ2atWCE06A11/XaT4RSQ7RBtQO59zOyJPgPigNYRpnZ5wBK1fCZ5+FXYmISOxFG1CfmtlNQHUzOw5/P9TbsStLCjNgAFSrptN8IpIcog2oG4A1wLfAX4D3gFtiVZQULi0t/zRfTlKMRigiySzaXny5+E4RFzvnTnfO/cdFM4iflLkzzoBfftFpPhGp+EqabsPM7A4z+xWYB/xgZmvM7Lb4lCd7OvFEqF5dp/lEpOIr6QjqSnzvvaOdcwc45+oDnYFuZnZVrIuTvaWl+ZDSaT4RqehKCqizgaHOuR8jDc65xcCfgtckBIMGwapVMGVK2JWIiMROSQFVxTn3656Nzrk1QJXYlCQliZzm09h8IlKRlRRQO/fxNYmhmjV9l3Od5hORiqykgMows02FLJuBtvEoUAp3xhmwejVMnhx2JSIisVFsQDnnUpxztQtZajnndIovRCecADVqqDefiFRcUU9YKImlRg1/mm/MGNiliU9EpAJSQJVjQ4bAmjXw4YdhVyIiUvYUUOXYgAHQoAH85z9hVyIiUvYUUOVYlSpwzjnwzjt+lHMRkYpEAVXOnXee72r+7LNhVyIiUrYUUOVcy5bQsyc8/bQmMhSRikUBVQGcfz4sXgwffxx2JSIiZUcBVQEMHAj16qmzhIhULAqoCqBaNTjrLHjzTfh1r5ETRUTKJwVUBXH++bBzJ7zwQtiViIiUDQVUBXHUUdCliz/Np7mORaQiUEBVIBdcAHPnwiefhF2JiMj+U0BVIEOHQno6PPhg2JWIiOw/BVQFUq0aXHIJvPsuzJsXdjUiIvtHAVXBXHwxpKbCww+HXYmIyP5RQFUw6elw9tnw/PN+pHMRkfJKAVUBXXUVbN8OTzwRdiUiIvtOAVUBHXmkn3H3X//yQSUiUh4poCqoq6+G1avhpZfCrkREZN8ooCqoXr0gIwMeekg37opI+aSAqqDM/FHU999rSngRKZ8UUBXY4MFw8MFw//1hVyIiUnoKqAqsalXfo++jj2Dq1LCrEREpHQVUBXfhhVC/Ptx9d9iViIiUjgKqgktLgyuvhLffhtmzw65GRCR6CqgkcOmlUKsW/N//hV2JiEj0FFBJoF49P4jsa6/BDz+EXY2ISHQUUEniqqv8aOf33BN2JSIi0VFAJYkGDfyEhi+8AEuWhF2NiEjJFFBJ5JproFIluO++sCsRESlZzALKzJqY2cdmNtfMvjOzK4L2+mY2wcwWBI/1gnYzs0fNbKGZfWNmHQpsa3iw/gIzGx6rmiu6xo1hxAgYORJWrgy7GhGR4sXyCGoXcLVz7kigC3CJmbUGbgAmOedaApOC5wD9gZbBcgHwBPhAA24HOgOdgNsjoSald/31sGuXpoUXkcQXs4Byzq10zs0Ift4MzAUaAacAzwWrPQecGvx8CvC8874E6ppZQ6AfMME5t845tx6YABwfq7oruubNYehQP1fUr7+GXY2ISNHicg3KzJoC7YGpwEHOuZXgQwxoEKzWCFha4G3Lgrai2vf8HReY2TQzm7ZGU8kW68YbYetWeOSRsCsRESlazAPKzNKAMcCVzrlNxa1aSJsrpn33Bueecs5lOeey0tPT963YJNG6Nfzxj/DYY7BxY9jViIgULqYBZWZV8OH0knPujaB5VXDqjuBxddC+DGhS4O2NgRXFtMt+uPlmH07/+lfYlYiIFC6WvfgMeAaY65x7qMBL44BIT7zhwFsF2s8OevN1ATYGpwA/BPqaWb2gc0TfoE32Q/v20L8/PPww/PZb2NWIiOwtlkdQ3YCzgN5mNitYTgDuAY4zswXAccFzgPeAxcBC4D/AxQDOuXXAncDXwfL3oE320y23+I4STz0VdiUiInszVwHnA8/KynLTpk0Lu4xyoU8f+PZbWLgQatcOuxoRSUZmNt05l7Vnu0aSSHL33gtr1miMPhFJPAqoJJeVBX/6k78W9fPPYVcjIpJPASXcfTc4569JiYgkCgWUcMghfjqOF16A6dPDrkZExFNACQA33OCn5LjiCn80JSISNgWUAFCnjj/V99lnMGpU2NWIiCigpIARI/wNvNdeC1u2hF2NiCQ7BZTkSUnxQx8tXw533RV2NSKS7BRQspuuXeGcc/x8UfPmhV2NiCQzBZTs5d57oWZNuOwydZgQkfAooGQvDRr4U3wTJ8Lrr4ddjYgkKwWUFOrCCyEzE/76V3WYEJFwKKCkUJUr+w4Ty5bB3/8edjUikowUUFKkY46B88/3HSY+/zzsakQk2SigpFgPPuiHQjr7bJ3qE5H4UkBJsWrVgueeg8WL/Q28IiLxooCSEvXoAVdfDf/+N7z/ftjViEiyUEBJVO68E9q0gXPPhXXrwq5GRJKBAkqiUq2an47j11/h4ovDrkZEkoECSqLWvj3ccQeMHq0Rz0Uk9hRQUirXXQdduvijqOXLw65GRCoyBZSUSuXK8PzzsGOHvx6lsfpEJFYUUFJqLVvC/ffDhx/Ck0+GXY2IVFQKKNknF10E/fr5sfpmzw67GhGpiBRQsk/M/A289evDaafB2rVhVyQiFY0CSvbZQQfBmDG+s8TQoZCTE3ZFIlKRKKBkv3TuDI8/DhMmwE03hV2NiFQklcMuQMq/c8+FadPgvvvgqKPgrLPCrkhEKgIdQUmZeOQR6NXLh9WkSWFXIyIVgQJKykTVqvDGG3D44TBwIHz7bdgViUh5p4CSMlO3rh/tPC0N+vf3s/GKiOwrBZSUqSZNfEht2uRDauPGsCsSkfJKASVlrl07f7pv3jx/um/nzrArEpHySAElMXHssTByJHz0EZxzDuTmhl2RiJQ36mYuMXPWWf4m3htvhIYN4cEHw65IRMoTBZTE1PXXw4oV8NBD0KiRH7tPRCQaCiiJKTN4+GFYuRKuvhrq1YMRI8KuSkTKAwWUxFxKip8uftMmfyNvSgqcfXbYVYlIolMnCYmLatVg7Fjo3dt3mnjppbArEpFEp4CSuKleHcaNg549/RHUqFFhVyQiiUwBJXFVowa8/Tb8/vfwpz/Ba6+FXZGIJCoFlMRdzZrw7rvQpYufR2rMmLArEpFEpICSUKSl+SGROnWCIUP89SkRkYIUUBKaWrXggw+gY0c4/XR49tmwKxKRRKKAklDVru1n4+3Vy98fdc894FzYVYlIIlBASehq1fLXpIYO9cMiXXGFxu4TEd2oKwmialV48UU/Zt9DD8GqVfD885CaGnZlIhIWBZQkjEqV/ICyBx8M11zjQ+qNN6B+/bArE5EwxOwUn5mNNLPVZjanQFt9M5tgZguCx3pBu5nZo2a20My+MbMOBd4zPFh/gZkNj1W9kjiuvhpefhm++AK6doUFC8KuSETCEMtrUM8Cx+/RdgMwyTnXEpgUPAfoD7QMlguAJ8AHGnA70BnoBNweCTWp2IYOhUmTYO1a3xX9vffCrkhE4i1mAeWcmwys26P5FOC54OfngFMLtD/vvC+BumbWEOgHTHDOrXPOrQcmsHfoSQX1+9/D119D06YwYADcdZc6T4gkk3j34jvIObcSIHhsELQ3ApYWWG9Z0FZUuySJZs3gs89g2DC49VY/hfymTWFXJSLxkCjdzK2QNldM+94bMLvAzKaZ2bQ1a9aUaXESrho1/HQd//gHvPMOZGbCl1+GXZWIxFq8A2pVcOqO4HF10L4MaFJgvcbAimLa9+Kce8o5l+Wcy0pPTy/zwiVcZv7+qE8/9af5fv97uPtuyMkJuzIRiZV4B9Q4INITbzjwVoH2s4PefF2AjcEpwA+BvmZWL+gc0TdokyTVrRvMmgWDBsEtt/j5pX7+OeyqRCQWYtnN/BXgC6CVmS0zs3OBe4DjzGwBcFzwHOA9YDGwEPgPcDGAc24dcCfwdbD8PWiTJFa3ru+G/txzMGMGZGRo2g6RishcBRz4LCsry02bNi3sMiQOFi2CM8+EqVPhj3+E++6D5s3DrkpESsPMpjvnsvZsT5ROEiL7pEULmDLFd0F//3048kg/nt+WLWFXJiL7SwEl5V6VKnDzzX7EiSFD/IjoLVvCf/4Du3aFXZ2I7CsFlFQYBx/sr0t98YU/zXfBBb5LukahECmfFFBS4XTpAv/7n59KfscOOPFEOO00WLq05PeKSOJQQEmFZOZHnfjuO7j3XvjwQ2jdGu6/H7ZtC7s6EYmGAkoqtKpV4brrfFD94Q/+5xYt4PHHITs77OpEpDgKKEkKzZr5YZI+/RQOOwwuuQTatoU339QU8yKJSgElSaVHDx9S48blnwbs1Ak++EBBJZJoFFCSdMzgpJPg229h5EhYswb69/edK959V0ElkigUUJK0KleGESNg/nx46ilYvdrPO9Wxox86SQPRioRLASVJr2pVOP98H1QjR/pRKM44A444Ap58ErZuDbtCkeSkgBIJVKnij6jmzvVHUHXqwIUXwiGH+JEqVhQ60YuIxIoCSmQPKSlw+ul+uvlPP4Xu3eH//T849FAYPBgmT9Z1KpF4UECJFMHM9/p7800/zt/ll8P48f5+qnbt4NFHYZ0mfxGJGQWUSBRatIAHH4Tly+GZZyA11c/we/DBMHQoTJzoZ/oVkbKjgBIphRo14M9/hmnT/My+F1zgh1E67jgfYnfeqTH/RMqKAkpkH2Vk+NN8K1b4GX5btIDbboOmTeGEE/xgtTt3hl2lSPmlgBLZT9Wq5Z/mW7QIbroJvvnGd7Ro3Biuucb3DBSR0lFAiZSh5s39ab6ffvKjUnTvDo884kdSP+YYf/1Ks/2KREcBJRIDKSn5p/mWL4cHHoD16+G886BhQzj3XN87cP36sCsVSVzmKuANHVlZWW7atGlhlyGyG+f8bL/PPAOvvuqPpCpVgg4d/NiAf/yjP9IyC7tSkfgys+nOuay92hVQIvG3cydMnQqTJsGECT64nINGjeDYY/3Sp48/2hKp6BRQIgls+XJ47z3f0WLSJFi71re3aePDql8/f4NwjRrh1ikSCwookXIiNxdmz/ZhNXGiH1pp+3Z/c/Af/pAfVhkZfkR2kfJOASVSTm3fDlOmwPvv+6OsH37w7Wlp0K2bH46pb18/TYiuX0l5pIASqSCWL/eBNWWKP7qaM8e3/+53Pqj69fOnBRs0CLdOkWgpoEQqqF9/9UdW77/vO1xErl916OBnCu7fHzp31ulASVwKKJEkkJsLM2f68QE/+AA+/9zPDJyW5m8a7tXLL+3b+3u1RBKBAkokCW3Y4I+qPvoIPvkE5s3z7XXq+MDq2dMvmZkKLAmPAkpEWLnSB1VkmT/ft9eq5U8JFlxatVJoSXwooERkLytW+FmD//c/mDHDd2/fts2/Vr26P7IqGFqtW0PVqqGWLBWQAkpESrRrl+/GPmNG/jJzJmze7F+vWhXatt09tNq29WEmsq8UUCKyT3Jz/TQiBUNrxoz86e5TUvyR1VFH+dOChx+ev9SqFW7tUj4ooESkzDgHP/+8e2B9/72fZqTgV0qTJj6oWrSAww6Dli39Y4sWOuqSfEUFlO6MEJFSM4NDD/XLaaflt2/f7o+2fvjB9xj8/ntYsMBPOxK5PyuiSZPdQ6tlS780b67wEk8BJSJlplo1P8BtmzZ7v7ZhAyxc6JcFC/yycCG88Ya/2TjCzI/q3rSpD8CmTXf/+ZBD/LiEUvEpoEQkLurWhawsv+xpz/BatMifLvzsMxg1yt9sXFDDhtC4sR/eqUkTH1pNmvj23/3OL3XramzC8k4BJSKhKy68du3y4w/+9BMsWZK/rFjhH//3v8JnJq5a1R+JNW7slwMPhHr1ID3dB1h6um+LLLrnK/EooEQkoVWunH+9q0ePwtfZvBmWLYNfftl9Wb4cli71k0OuXQsbNxb+fjMfUunpcMABey/16+cvBZ/rWllsKaBEpNyrVQuOPNIvxcnJ8de7fvnFP65dC2vW+GXVqvyfFy7MD7WdO4veXrVqu4dXJMAKBlthz3Wzc3QUUCKSNFJS4KCD/BIN5+C33/wpxHXrfGCtW7f7snatf33t2uiDLS2t6ACrX9+/XnCpVSt/SUuDmjWT45SkAkpEpAhm+SHRpEn074sEWyTACi6Ftf30U37QRXtrao0aULu2XyKhVbNm/s+1a/tBgSPr1K69d8jVqJG/VK+eeJ1KFFAiImWsYLAdckj078vJgU2bfLht2ZK/bN6c37558+5tGzf657/95k9b/vSTf75pk19KMxZD9eqFLwWDLBJwkZBr1AjOOafUuygqCigRkQSRkuJ7GtarVzbbc273sIoE2+bNsHXr3stvv/mbrbdt80vk561b/TW6gsG5ebMP1KOPVkCJiEgpmeWf1mvUqGy37RxkZ5fuCK20FFAiIlJqZrHvjVgptpsXERHZNwooERFJSAooERFJSOUmoMzseDP7wcwWmtkNYdcjIiKxVS4CysxSgH8B/YHWwFAzax1uVSIiEkvlIqCATsBC59xi59xOYBRwSsg1iYhIDJWXgGoELC3wfFnQlsfMLjCzaWY2bc2aNXEtTkREyl55CajCRoja7fYw59xTzrks51xWenp6nMoSEZFYKS8BtQwoOFRjY2BFSLWIiEgclJeA+hpoaWbNzKwqMAQYF3JNIiISQ+ViqCPn3C4zuxT4EEgBRjrnvgu5LBERiaFyEVAAzrn3gPfCrkNEROKjvJziExGRJKOAEhGRhGQulpN5hMTM1gA/7ccmDgR+LaNyyjvtC0/7wdN+yKd94ZXFfjjUObfX/UEVMqD2l5lNc85lhV1HItC+8LQfPO2HfNoXXiz3g07xiYhIQlJAiYhIQlJAFe6psAtIINoXnvaDp/2QT/vCi9l+0DUoERFJSDqCEhGRhKSAEhGRhKSA2kMyTS1vZiPNbLWZzSnQVt/MJpjZguCxXtBuZvZosF++MbMO4VVetsysiZl9bGZzzew7M7siaE/GfVHNzL4ys9nBvvhb0N7MzKYG+2J0MGgzZpYaPF8YvN401A9Qxswsxcxmmtk7wfOk2w9mtsTMvjWzWWY2LWiLy78NBVQBSTi1/LPA8Xu03QBMcs61BCYFz8Hvk5bBcgHwRJxqjIddwNXOuSOBLsAlwX/3ZNwXO4DezrkMIBM43sy6APcCDwf7Yj1wbrD+ucB659xhwMPBehXJFcDcAs+TdT/0cs5lFrjfKT7/NpxzWoIF6Ap8WOD5jcCNYdcV48/cFJhT4PkPQMPg54bAD8HPTwJDC1uvoi3AW8Bxyb4vgBrADKAzfqSAykF73r8T/AwDXYOfKwfrWdi1l9Hnbxx8+fYG3sFPnJqM+2EJcOAebXH5t6EjqN2VOLV8EjjIObcSIHhsELQnxb4JTs20B6aSpPsiOK01C1gNTAAWARucc7uCVQp+3rx9Eby+ETggrgXHzj+A64Dc4PkBJOd+cMB4M5tuZhcEbXH5t1FuptuIkxKnlk9iFX7fmFkaMAa40jm3yaywj+xXLaStwuwL51wOkGlmdYE3gSMLWy14rJD7wswGAKudc9PNrGekuZBVK/R+CHRzzq0wswbABDObV8y6ZbofdAS1O00tD6vMrCFA8Lg6aK/Q+8bMquDD6SXn3BtBc1Luiwjn3AbgE/x1ubpmFvmDtuDnzdsXwet1gHVxLTQ2ugEnm9kSYBT+NN8/SL79gHNuRfC4Gv8HSyfi9G9DAbU7TS3vP+/w4Ofh+Osxkfazg146XYCNkUP88s78odIzwFzn3EMFXkrGfZEeHDlhZtWBY/GdBD4GTg9W23NfRPbR6cBHLrj4UJ455250zjV2zjXFfw985Jw7kyTbD2ZW08xqRX4G+gJziNe/jbAvwCXaApwAzMefd7857Hpi/FlfAVYC2fi/fM7FnzefBCwIHusH6xq+h+Mi4FsgK+z6y3A//B5/GuIbYFawnJCk+6IdMDPYF3OA24L25sBXwELgNSA1aK8WPF8YvN487M8Qg33SE3gnGfdD8HlnB8t3ke/EeP3b0FBHIiKSkHSKT0REEpICSkREEpICSkREEpICSkREEpICSkREEpICSpKOmeUEIzPPNrMZZnZMGW//pj2ef15G2+1ZYFTtnmVZt5k1NbNhBZ5nmdmjZbV9kX2hgJJktM35kZkz8AMC/78y3v5uAeWcK9MADPQESrXdAiMgFKYpkBdQzrlpzrnL96kykTKigJJkVxs/bUJkLpv7zWxOMP/N4BLaG5rZ5OBobI6ZdTeze4DqQdtLwXpbgseeZvaJmb1uZvPM7KVgFAvM7ISg7X/BfDrvFFVwMKDthcBVwe/pHowAMcbMvg6WbsG6d5jZU2Y2Hng+OFKaEhw5Fjx6vAfoHmzvqj2O1uqb2Vjz8/t8aWbtCmx7ZPCZFpvZ5UF7TTN7NzhCnRPZXyKlpcFiJRlVNz9adzX8VAG9g/aB+DmQMoADga/NbDL+SKWw9mH46RbuNj+XWA3n3BQzu9Q5l1nE724PtMGPT/YZ0M38JHBPAj2ccz+a2SvFFe+cW2Jm/wa2OOceADCzl/HzFP3PzA7BT/8QGeS1I/B759w2M6sBHOec225mLfGjiWTh5/O5xjk3INhezwK/8m/ATOfcqWbWG3g+2B8ARwC9gFrAD2b2BH6OsRXOuRODbdUp7vOIFEUBJcloWyRAzKwr/sjiKPyQR684P5r3KjP7FDi6mPavgZHmB5od65ybFcXv/so5tyz43bPwp9a2AIudcz8G67yCn+ytNI4FWlv+COy1I2OoAeOcc9uCn6sA/zSzTCAHODyKbf8e+COAc+4jMzugQOi865zbAewws9XAQfghbh4ws3vxQwRNKeVnEQF0ik+SnHPuC/xRUTqFTxVAUe3OuclAD2A58IKZnR3Fr9xR4Occ/B+JRc7rUQqV8BPmZQZLI+fc5uC13wqsdxWwCn80mAVUjWLbxU2hsNfncc7Nxx+1fQv8PzO7rRSfQySPAkqSmpkdAaQAa4HJwGDzE/al48Pnq6LazexQ/JxB/8GPht4h2Gx2cFQVrXlA8+DaEkA012w240+rRYwHLi3wuTKLeF8dYKVzLhc4C//ZC9teQZOBM4Pt9gR+dc5tKqowMzsY2OqcexF4gPz9IlIqOsUnyShyDQr80cFw51yOmb2Jn8Z7Nv4I4Trn3C/FtA8HrjWzbPxpusgR1FPAN2Y2w/kpGooVXBu6GPjAzH7Fh2JJ3gZeN7NTgMuAy4F/mdk3+H/Xk/EdKfb0ODDGzAbhp46IHF19A+wys9nAs/gRzSPuAP4bbHsr+dMsFKUtcL+Z5eJHyr8ois8jsheNZi6SAMwszTm3JejV9y9ggXPu4bDrEgmTTvGJJIbzg6O67/Cn4Z4MtxyR8OkISkREEpKOoEREJCEpoEREJCEpoEREJCEpoEREJCEpoEREJCH9f58AcWrKo5zXAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {'n_estimators': 500,  # 迭代次数\n",
    "          'max_depth': 6,  # 基回归树最大深度\n",
    "          'min_samples_split': 5,  # 基回归树内部节点再划分所需最小样本数\n",
    "          'learning_rate': 0.01,  # 学习率\n",
    "          'loss': 'ls'}  # 损失函数\n",
    "\n",
    "reg = train_and_predict(params)\n",
    "plot_staged_loss(params, reg) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 可以发现max_depth过大时，模型泛化能力变得很差。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 其他参数不变，增大学习率learning_rate到0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集均方误差：3714.1889\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {'n_estimators': 500,  # 迭代次数\n",
    "          'max_depth': 4,  # 基回归树最大深度\n",
    "          'min_samples_split': 5,  # 基回归树内部节点再划分所需最小样本数\n",
    "          'learning_rate': 0.1,  # 学习率\n",
    "          'loss': 'ls'}  # 损失函数\n",
    "\n",
    "reg = train_and_predict(params)\n",
    "plot_staged_loss(params, reg) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 学习率过大时模型在测试集上的损失值会迅速达到最小，之后有可能反而增大（发生振荡）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. 其他参数不变，增大min_samples_split（内部节点再划分所需最小样本数）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集均方误差：2947.7259\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {'n_estimators': 500,  # 迭代次数\n",
    "          'max_depth': 4,  # 基回归树最大深度\n",
    "          'min_samples_split': 14,  # 基回归树内部节点再划分所需最小样本数\n",
    "          'learning_rate': 0.01,  # 学习率\n",
    "          'loss': 'ls'}  # 损失函数\n",
    "\n",
    "reg = train_and_predict(params)\n",
    "plot_staged_loss(params, reg) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 增大min_samples_split使得每颗树划分结点更苛刻，能够减小过拟合。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GBDT的优缺点\n",
    "主要优点\n",
    "1. 可以灵活处理各种类型的数据，包括连续值和离散值。\n",
    "2. 在相对少的调参时间情况下，预测的准确率也可以比较高。这个是相对 SVM 来说的。\n",
    "3. 使用一些健壮的损失函数，对异常值的鲁棒性非常强。比如 Huber 损失函数和 Quantile 损失函数。\n",
    "\n",
    "主要缺点\n",
    "1. 由于弱学习器之间存在依赖关系，难以并行训练数据。不过可以通过自采样的 SGBT 来达到部分并行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reference\n",
    "\n",
    "1. [深入理解GBDT回归算法](https://mp.weixin.qq.com/s?__biz=MzI5NDMzMjY1MA==&mid=2247485231&idx=1&sn=1fe835f3bd9f6d2062273a02b78dea2f&chksm=ec6536aadb12bfbc548ab0a2a1cbf1c77e9d2e8517886f54b616d6f8aa8d34dc371542a82919&scene=158#rd)\n",
    "2. [scikit-learn 梯度提升树(GBDT)调参小结](https://www.cnblogs.com/pinard/p/6143927.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
